\n \n

Tutorial

\n

The tutorial is here: Tutorial.

\n \n\n\n## How to Use?\n1. Set up the Riva Server and Audio2Face as indicated by the steps in the Tutorial.\n2. After step 1 has been set up, launch both the Riva Server and Audio2Face.\n3. Fill in the URI in the config.py in the following format: external IP of your Riva Server:Port of your Riva Server. \n 1. For example, if the external IP of the Riva Sever is \"12.34.56.789\" and the port of the Riva Server is \"50050\". Then the content in config.py will be \n > URI = \"12.34.56.789:50050\"\n3. Check if all the prerequisties are configured.\n4. Run main.py.\n\n\n\n## Inspired by https://github.com/metaiintw/build-an-avatar-with-ASR-TTS-Transformer-Omniverse-Audio2Face\n## Limitations: Currently Using the Wikipedia API for NLP Context Query, so it can only handle Q&A questions that can be answer by Wikipedia.\n"},"size":{"kind":"number","value":1474,"string":"1,474"},"lang":{"kind":"string","value":"Markdown"},"avg_line_length":{"kind":"number","value":34.11904680668936,"string":"34.119047"},"max_line_length":{"kind":"number","value":157,"string":"157"},"alphanum_fraction":{"kind":"number","value":0.7170963360128246,"string":"0.717096"}}},{"rowIdx":36,"cells":{"file_path":{"kind":"string","value":"zslrmhb/Omniverse-Virtual-Assisstant/LICENSE.md"},"content":{"kind":"string","value":"MIT License\n\nCopyright (c) 2023 Hongbin Miao\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"},"size":{"kind":"number","value":1069,"string":"1,069"},"lang":{"kind":"string","value":"Markdown"},"avg_line_length":{"kind":"number","value":47.63636147107448,"string":"47.636361"},"max_line_length":{"kind":"number","value":78,"string":"78"},"alphanum_fraction":{"kind":"number","value":0.8054256306778057,"string":"0.805426"}}},{"rowIdx":37,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/README.md"},"content":{"kind":"string","value":"# Pegasus Simulator\n\n\n\n\n\n**Pegasus Simulator** is a framework built on top of [NVIDIA\nOmniverse](https://docs.omniverse.nvidia.com/) and [Isaac\nSim](https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/overview.html). It is designed to provide an easy yet powerful way of simulating the dynamics of vehicles. It provides a simulation interface for [PX4](https://px4.io/) integration as well as a custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions.\n\n

\n\n\n

\n\n\nCheck the provided documentation [here](https://pegasussimulator.github.io/PegasusSimulator/) to discover how to install and use this framework.\n\n## Citation\n\nIf you find Pegasus Simulator useful in your academic work, please cite the paper below. It is also available [here](https://arxiv.org/abs/2307.05263).\n```\n@misc{jacinto2023pegasus,\n title={Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation}, \n author={Marcelo Jacinto and João Pinto and Jay Patrikar and John Keller and Rita Cunha and Sebastian Scherer and António Pascoal},\n year={2023},\n eprint={2307.05263},\n archivePrefix={arXiv},\n primaryClass={cs.RO}\n}\n```\n\n## Main Developer Team\n\nThis simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027.\n\n* Project Founder\n\t* [Marcelo Jacinto](https://github.com/MarceloJacinto), under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon)\n* Architecture\n * [Marcelo Jacinto](https://github.com/MarceloJacinto)\n\t* [João Pinto](https://github.com/jschpinto)\n* Multirotor Dynamic Simulation and Control\n * [Marcelo Jacinto](https://github.com/MarceloJacinto)\n* Example Applications\n\t* [Marcelo Jacinto](https://github.com/MarceloJacinto)\n\t* [João Pinto](https://github.com/jschpinto)\n\nAlso check the always up-to-date [Github contributors list](https://github.com/PegasusSimulator/PegasusSimulator/graphs/contributors) with all the open-source contributors.\n\n## Project Roadmap\n\nAn high level project roadmap is available [here](https://pegasussimulator.github.io/PegasusSimulator/source/references/roadmap.html).\n\n## Support and Contributing\n\nWe welcome new contributions from the community to improve this work. Please check the [Contributing](https://pegasussimulator.github.io/PegasusSimulator/source/references/contributing.html) section in the documentation for the guidelines on how to help improve and support this project.\n\n* Use [Discussions](https://github.com/PegasusSimulator/PegasusSimulator/discussions) for discussing ideas, asking questions, and requests features.\n* Use [Issues](https://github.com/PegasusSimulator/PegasusSimulator/issues) to track work in development, bugs and documentation issues.\n* Use [Pull Requests](https://github.com/PegasusSimulator/PegasusSimulator/pulls) to fix bugs or contribute directly with your own ideas, code, examples or improve documentation.\n\n## Licenses\n\nPegasus Simulator is released under [BSD-3 License](LICENSE). The license files of its dependencies and assets are present in the [`docs/licenses`](docs/licenses) directory.\n\nNVIDIA Isaac Sim is available freely under [individual license](https://www.nvidia.com/en-us/omniverse/download/). \n\nPX4-Autopilot is available as an open-source project under [BSD-3 License](https://github.com/PX4/PX4-Autopilot).\n\n## Project Sponsors\n- Dynamics Systems and Ocean Robotics (DSOR) group of the Institute for Systems and Robotics (ISR), a research unit of the Laboratory of Robotics and Engineering Systems (LARSyS).\n- Instituto Superior Técnico, Universidade de Lisboa\n\nThe work developed by Marcelo Jacinto and João Pinto was supported by Ph.D. grants funded by Fundação para a Ciência e Tecnologia (FCT).\n\n

\n \n \n \n \n \n

\n"},"size":{"kind":"number","value":4976,"string":"4,976"},"lang":{"kind":"string","value":"Markdown"},"avg_line_length":{"kind":"number","value":58.96385471127886,"string":"58.963855"},"max_line_length":{"kind":"number","value":417,"string":"417"},"alphanum_fraction":{"kind":"number","value":0.7624598069207275,"string":"0.76246"}}},{"rowIdx":38,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/examples/1_px4_single_vehicle.py"},"content":{"kind":"string","value":"#!/usr/bin/env python\n\"\"\"\n| File: 1_px4_single_vehicle.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| 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.\n\"\"\"\n\n# Imports to start Isaac Sim from this script\nimport carb\nfrom omni.isaac.kit import SimulationApp\n\n# Start Isaac Sim's simulation environment\n# Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash\n# as this is the object that will load all the extensions and load the actual simulator.\nsimulation_app = SimulationApp({\"headless\": False})\n\n# -----------------------------------\n# The actual script should start here\n# -----------------------------------\nimport omni.timeline\nfrom omni.isaac.core.world import World\n\n# Import the Pegasus API for simulating drones\nfrom pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend, MavlinkBackendConfig\nfrom pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\n# Auxiliary scipy and numpy modules\nimport os.path\nfrom scipy.spatial.transform import Rotation\n\nclass PegasusApp:\n \"\"\"\n A Template class that serves as an example on how to build a simple Isaac Sim standalone App.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Method that initializes the PegasusApp and is used to setup the simulation environment.\n \"\"\"\n\n # Acquire the timeline that will be used to start/stop the simulation\n self.timeline = omni.timeline.get_timeline_interface()\n\n # Start the Pegasus Interface\n self.pg = PegasusInterface()\n\n # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, \n # spawning asset primitives, etc.\n self.pg._world = World(**self.pg._world_settings)\n self.world = self.pg.world\n\n # Launch one of the worlds provided by NVIDIA\n self.pg.load_environment(SIMULATION_ENVIRONMENTS[\"Curved Gridroom\"])\n\n # Create the vehicle\n # Try to spawn the selected robot in the world to the specified namespace\n config_multirotor = MultirotorConfig()\n # Create the multirotor configuration\n mavlink_config = MavlinkBackendConfig({\n \"vehicle_id\": 0,\n \"px4_autolaunch\": True,\n \"px4_dir\": self.pg.px4_path,\n \"px4_vehicle_model\": self.pg.px4_default_airframe # CHANGE this line to 'iris' if using PX4 version bellow v1.14\n })\n config_multirotor.backends = [MavlinkBackend(mavlink_config)]\n\n Multirotor(\n \"/World/quadrotor\",\n ROBOTS['Iris'],\n 0,\n [0.0, 0.0, 0.07],\n Rotation.from_euler(\"XYZ\", [0.0, 0.0, 0.0], degrees=True).as_quat(),\n config=config_multirotor,\n )\n\n # Reset the simulation environment so that all articulations (aka robots) are initialized\n self.world.reset()\n\n # Auxiliar variable for the timeline callback example\n self.stop_sim = False\n\n def run(self):\n \"\"\"\n Method that implements the application main loop, where the physics steps are executed.\n \"\"\"\n\n # Start the simulation\n self.timeline.play()\n\n # The \"infinite\" loop\n while simulation_app.is_running() and not self.stop_sim:\n\n # Update the UI of the app and perform the physics step\n self.world.step(render=True)\n \n # Cleanup and stop\n carb.log_warn(\"PegasusApp Simulation App is closing.\")\n self.timeline.stop()\n simulation_app.close()\n\ndef main():\n\n # Instantiate the template app\n pg_app = PegasusApp()\n\n # Run the application loop\n pg_app.run()\n\nif __name__ == \"__main__\":\n main()\n"},"size":{"kind":"number","value":4153,"string":"4,153"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":35.43859618036319,"string":"35.438596"},"max_line_length":{"kind":"number","value":192,"string":"192"},"alphanum_fraction":{"kind":"number","value":0.6672285093505349,"string":"0.667229"}}},{"rowIdx":39,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/examples/6_paper_results.py"},"content":{"kind":"string","value":"#!/usr/bin/env python\n\"\"\"\n| File: python_control_backend.py\n| Author: Marcelo Jacinto and Joao Pinto (marcelo.jacinto@tecnico.ulisboa.pt, joao.s.pinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: This files serves as an example on how to use the control backends API to create a custom controller \nfor the vehicle from scratch and use it to perform a simulation, without using PX4 nor ROS. NOTE: to see the HDR\nenvironment as shown in the video and paper, you must have opened ISAAC SIM at least once thorugh the OMNIVERSE APP,\notherwise, the path to the HDR environment is not recognized.\n\"\"\"\n\n# Imports to start Isaac Sim from this script\nimport carb\nfrom omni.isaac.kit import SimulationApp\n\n# Start Isaac Sim's simulation environment\n# Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash\n# as this is the object that will load all the extensions and load the actual simulator.\nsimulation_app = SimulationApp({\"headless\": False})\n# -----------------------------------\n# The actual script should start here\n# -----------------------------------\nimport omni.timeline\nfrom omni.isaac.core.world import World\n\n# Used for adding extra lights to the environment\nimport omni.isaac.core.utils.prims as prim_utils\n\nimport omni.kit.commands\nfrom pxr import Sdf\n\n# Import the Pegasus API for simulating drones\nfrom pegasus.simulator.params import ROBOTS\nfrom pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig\nfrom pegasus.simulator.logic.dynamics.linear_drag import LinearDrag\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\n\n# Import the custom python control backend\nfrom utils.nonlinear_controller import NonlinearController\n\n# Auxiliary scipy and numpy modules\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\n# Use os and pathlib for parsing the desired trajectory from a CSV file\nimport os\nfrom pathlib import Path\n\nfrom omni.isaac.debug_draw import _debug_draw\n\n\nclass PegasusApp:\n \"\"\"\n A Template class that serves as an example on how to build a simple Isaac Sim standalone App.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Method that initializes the PegasusApp and is used to setup the simulation environment.\n \"\"\"\n\n # Acquire the timeline that will be used to start/stop the simulation\n self.timeline = omni.timeline.get_timeline_interface()\n\n # Start the Pegasus Interface\n self.pg = PegasusInterface()\n\n # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, \n # spawning asset primitives, etc.\n self.pg._world_settings = {\"physics_dt\": 1.0 / 500.0, \"stage_units_in_meters\": 1.0, \"rendering_dt\": 1.0 / 60.0}\n self.pg._world = World(**self.pg._world_settings)\n self.world = self.pg.world\n\n prim_utils.create_prim(\n \"/World/Light/DomeLight\",\n \"DomeLight\",\n position=np.array([1.0, 1.0, 1.0]),\n attributes={\n \"inputs:intensity\": 5e3,\n \"inputs:color\": (1.0, 1.0, 1.0),\n \"inputs:texture:file\": \"omniverse://localhost/NVIDIA/Assets/Skies/Indoor/ZetoCGcom_ExhibitionHall_Interior1.hdr\"\n }\n )\n\n # Get the current directory used to read trajectories and save results\n self.curr_dir = str(Path(os.path.dirname(os.path.realpath(__file__))).resolve())\n\n # Create the vehicle 1\n # Try to spawn the selected robot in the world to the specified namespace\n config_multirotor1 = MultirotorConfig()\n config_multirotor1.drag = LinearDrag([0.0, 0.0, 0.0])\n\n # Use the nonlinear controller with the built-in exponential trajectory\n config_multirotor1.backends = [NonlinearController(\n trajectory_file=None,\n results_file=self.curr_dir + \"/results/statistics_1.npz\")]\n\n Multirotor(\n \"/World/quadrotor1\",\n ROBOTS['Iris'],\n 1,\n [-5.0,0.00,1.00],\n Rotation.from_euler(\"XYZ\", [0.0, 0.0, 0.0], degrees=True).as_quat(),\n config=config_multirotor1,\n )\n\n # Create the vehicle 2\n #Try to spawn the selected robot in the world to the specified namespace\n config_multirotor2 = MultirotorConfig()\n\n # Use the nonlinear controller with the built-in exponential trajectory\n config_multirotor2.backends = [NonlinearController(\n trajectory_file=None,\n results_file=self.curr_dir + \"/results/statistics_2.npz\",\n reverse=True)]\n\n Multirotor(\n \"/World/quadrotor2\",\n ROBOTS['Iris'],\n 2,\n [-5.0,4.5,1.0],\n Rotation.from_euler(\"XYZ\", [0.0, 0.0, 0.0], degrees=True).as_quat(),\n config=config_multirotor2,\n )\n\n # Set the camera to a nice position so that we can see the 2 drones almost touching each other\n self.pg.set_viewport_camera([1.0, 5.15, 1.65], [0.0, -1.65, 3.3])\n\n # Draw the lines of the desired trajectory in Isaac Sim with the same color as the output plots for the paper\n gamma = np.arange(start=-5.0, stop=5.0, step=0.01)\n num_samples = gamma.size\n trajectory1 = [config_multirotor1.backends[0].pd(gamma[i], 0.6) for i in range(num_samples)]\n trajectory2 = [config_multirotor2.backends[0].pd(gamma[i], 0.6, reverse=True) for i in range(num_samples)]\n\n draw = _debug_draw.acquire_debug_draw_interface()\n point_list_1 = [(trajectory1[i][0], trajectory1[i][1], trajectory1[i][2]) for i in range(num_samples)]\n draw.draw_lines_spline(point_list_1, (31/255, 119/255, 180/255, 1), 5, False)\n\n point_list_2 = [(trajectory2[i][0], trajectory2[i][1], trajectory2[i][2]) for i in range(num_samples)]\n draw.draw_lines_spline(point_list_2, (255/255, 0, 0, 1), 5, False)\n\n # Reset the world\n self.world.reset()\n\n def run(self):\n \"\"\"\n Method that implements the application main loop, where the physics steps are executed.\n \"\"\"\n\n # Start the simulation\n self.timeline.play()\n\n # The \"infinite\" loop\n while simulation_app.is_running():\n\n # Update the UI of the app and perform the physics step\n self.world.step(render=True)\n \n # Cleanup and stop\n carb.log_warn(\"PegasusApp Simulation App is closing.\")\n self.timeline.stop()\n simulation_app.close()\n\ndef main():\n\n # Instantiate the template app\n pg_app = PegasusApp()\n\n # Run the application loop\n pg_app.run()\n\nif __name__ == \"__main__\":\n main()\n"},"size":{"kind":"number","value":6750,"string":"6,750"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":37.798850357477875,"string":"37.79885"},"max_line_length":{"kind":"number","value":128,"string":"128"},"alphanum_fraction":{"kind":"number","value":0.6527407406440384,"string":"0.652741"}}},{"rowIdx":40,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/examples/5_python_multi_vehicle.py"},"content":{"kind":"string","value":"#!/usr/bin/env python\n\"\"\"\n| File: python_control_backend.py\n| Author: Marcelo Jacinto and Joao Pinto (marcelo.jacinto@tecnico.ulisboa.pt, joao.s.pinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: This files serves as an example on how to use the control backends API to create a custom controller \nfor the vehicle from scratch and use it to perform a simulation, without using PX4 nor ROS.\n\"\"\"\n\n# Imports to start Isaac Sim from this script\nimport carb\nfrom omni.isaac.kit import SimulationApp\n\n# Start Isaac Sim's simulation environment\n# Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash\n# as this is the object that will load all the extensions and load the actual simulator.\nsimulation_app = SimulationApp({\"headless\": False})\n\n# -----------------------------------\n# The actual script should start here\n# -----------------------------------\nimport omni.timeline\nfrom omni.isaac.core.world import World\n\n# Used for adding extra lights to the environment\nimport omni.isaac.core.utils.prims as prim_utils\n\n# Import the Pegasus API for simulating drones\nfrom pegasus.simulator.params import ROBOTS\nfrom pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\n\n# Import the custom python control backend\nfrom utils.nonlinear_controller import NonlinearController\n\n# Auxiliary scipy and numpy modules\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\n# Use os and pathlib for parsing the desired trajectory from a CSV file\nimport os\nfrom pathlib import Path\n\nimport random\nfrom omni.isaac.debug_draw import _debug_draw\n\n\nclass PegasusApp:\n \"\"\"\n A Template class that serves as an example on how to build a simple Isaac Sim standalone App.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Method that initializes the PegasusApp and is used to setup the simulation environment.\n \"\"\"\n\n # Acquire the timeline that will be used to start/stop the simulation\n self.timeline = omni.timeline.get_timeline_interface()\n\n # Start the Pegasus Interface\n self.pg = PegasusInterface()\n\n # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, \n # spawning asset primitives, etc.\n self.pg._world = World(**self.pg._world_settings)\n self.world = self.pg.world\n\n # Add a custom light with a high-definition HDR surround environment of an exhibition hall,\n # instead of the typical ground plane\n prim_utils.create_prim(\n \"/World/Light/DomeLight\",\n \"DomeLight\",\n position=np.array([1.0, 1.0, 1.0]),\n attributes={\n \"inputs:intensity\": 5e3,\n \"inputs:color\": (1.0, 1.0, 1.0),\n \"inputs:texture:file\": \"omniverse://localhost/NVIDIA/Assets/Skies/Indoor/ZetoCGcom_ExhibitionHall_Interior1.hdr\"\n }\n )\n\n # Get the current directory used to read trajectories and save results\n self.curr_dir = str(Path(os.path.dirname(os.path.realpath(__file__))).resolve())\n\n # Create the vehicle 1\n # Try to spawn the selected robot in the world to the specified namespace\n config_multirotor1 = MultirotorConfig()\n config_multirotor1.backends = [NonlinearController(\n trajectory_file=self.curr_dir + \"/trajectories/pitch_relay_90_deg_1.csv\",\n results_file=self.curr_dir + \"/results/statistics_1.npz\",\n Ki=[0.5, 0.5, 0.5],\n Kr=[2.0, 2.0, 2.0])]\n\n Multirotor(\n \"/World/quadrotor1\",\n ROBOTS['Iris'],\n 1,\n [0,-1.5, 8.0],\n Rotation.from_euler(\"XYZ\", [0.0, 0.0, 0.0], degrees=True).as_quat(),\n config=config_multirotor1,\n )\n\n # Create the vehicle 2\n #Try to spawn the selected robot in the world to the specified namespace\n config_multirotor2 = MultirotorConfig()\n config_multirotor2.backends = [NonlinearController(\n trajectory_file=self.curr_dir + \"/trajectories/pitch_relay_90_deg_2.csv\",\n results_file=self.curr_dir + \"/results/statistics_2.npz\",\n Ki=[0.5, 0.5, 0.5],\n Kr=[2.0, 2.0, 2.0])]\n\n Multirotor(\n \"/World/quadrotor2\",\n ROBOTS['Iris'],\n 2,\n [2.3,-1.5, 8.0],\n Rotation.from_euler(\"XYZ\", [0.0, 0.0, 0.0], degrees=True).as_quat(),\n config=config_multirotor2,\n )\n\n # Set the camera to a nice position so that we can see the 2 drones almost touching each other\n self.pg.set_viewport_camera([7.53, -1.6, 4.96], [0.0, 3.3, 7.0])\n\n # Read the trajectories and plot them inside isaac sim\n trajectory1 = np.flip(np.genfromtxt(self.curr_dir + \"/trajectories/pitch_relay_90_deg_1.csv\", delimiter=','), axis=0)\n num_samples1,_ = trajectory1.shape\n trajectory2 = np.flip(np.genfromtxt(self.curr_dir + \"/trajectories/pitch_relay_90_deg_2.csv\", delimiter=','), axis=0)\n num_samples2,_ = trajectory2.shape\n\n # Draw the lines of the desired trajectory in Isaac Sim with the same color as the output plots for the paper\n draw = _debug_draw.acquire_debug_draw_interface()\n point_list_1 = [(trajectory1[i,1], trajectory1[i,2], trajectory1[i,3]) for i in range(num_samples1)]\n draw.draw_lines_spline(point_list_1, (31/255, 119/255, 180/255, 1), 5, False)\n\n point_list_2 = [(trajectory2[i,1], trajectory2[i,2], trajectory2[i,3]) for i in range(num_samples2)]\n draw.draw_lines_spline(point_list_2, (255/255, 0, 0, 1), 5, False)\n\n self.world.reset()\n\n def run(self):\n \"\"\"\n Method that implements the application main loop, where the physics steps are executed.\n \"\"\"\n\n # Start the simulation\n self.timeline.play()\n\n # The \"infinite\" loop\n while simulation_app.is_running():\n\n # Update the UI of the app and perform the physics step\n self.world.step(render=True)\n \n # Cleanup and stop\n carb.log_warn(\"PegasusApp Simulation App is closing.\")\n self.timeline.stop()\n simulation_app.close()\n\ndef main():\n\n # Instantiate the template app\n pg_app = PegasusApp()\n\n # Run the application loop\n pg_app.run()\n\nif __name__ == \"__main__\":\n main()"},"size":{"kind":"number","value":6518,"string":"6,518"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":37.80357120355017,"string":"37.803571"},"max_line_length":{"kind":"number","value":128,"string":"128"},"alphanum_fraction":{"kind":"number","value":0.642988646725531,"string":"0.642989"}}},{"rowIdx":41,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/examples/0_template_app.py"},"content":{"kind":"string","value":"#!/usr/bin/env python\n\"\"\"\n| File: 0_template_app.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: This files serves as a template on how to build a clean and simple Isaac Sim based standalone App.\n\"\"\"\n\n# Imports to start Isaac Sim from this script\nimport carb\nfrom omni.isaac.kit import SimulationApp\n\n# Start Isaac Sim's simulation environment\n# Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash\n# as this is the object that will load all the extensions and load the actual simulator.\nsimulation_app = SimulationApp({\"headless\": False})\n\n# -----------------------------------\n# The actual script should start here\n# -----------------------------------\nimport omni.timeline\nfrom omni.isaac.core import World\n\nclass Template:\n \"\"\"\n A Template class that serves as an example on how to build a simple Isaac Sim standalone App.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Method that initializes the template App and is used to setup the simulation environment.\n \"\"\"\n \n # Acquire the timeline that will be used to start/stop the simulation\n self.timeline = omni.timeline.get_timeline_interface()\n\n # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, \n # spawning asset primitives, etc.\n self.world = World()\n\n # Create a ground plane for the simulation\n self.world.scene.add_default_ground_plane()\n\n # Create an example physics callback\n self.world.add_physics_callback('template_physics_callback', self.physics_callback)\n\n # Create an example render callback\n self.world.add_render_callback('template_render_callback', self.render_callback)\n\n # Create an example timeline callback\n self.world.add_timeline_callback('template_timeline_callback', self.timeline_callback)\n\n # Reset the simulation environment so that all articulations (aka robots) are initialized\n self.world.reset()\n\n # Auxiliar variable for the timeline callback example\n self.stop_sim = False\n\n def physics_callback(self, dt: float):\n \"\"\"An example physics callback. It will get invoked every physics step.\n\n Args:\n dt (float): The time difference between the previous and current function call, in seconds.\n \"\"\"\n carb.log_info(\"This is a physics callback. It is called every \" + str(dt) + \" seconds!\")\n\n def render_callback(self, data):\n \"\"\"An example render callback. It will get invoked for every rendered frame.\n\n Args:\n data: Rendering data.\n \"\"\"\n carb.log_info(\"This is a render callback. It is called every frame!\")\n\n def timeline_callback(self, timeline_event):\n \"\"\"An example timeline callback. It will get invoked every time a timeline event occurs. In this example,\n we will check if the event is for a 'simulation stop'. If so, we will attempt to close the app\n\n Args:\n timeline_event: A timeline event\n \"\"\"\n if self.world.is_stopped():\n self.stop_sim = True\n\n def run(self):\n \"\"\"\n Method that implements the application main loop, where the physics steps are executed.\n \"\"\"\n\n # Start the simulation\n self.timeline.play()\n\n # The \"infinite\" loop\n while simulation_app.is_running() and not self.stop_sim:\n\n # Update the UI of the app and perform the physics step\n self.world.step(render=True)\n \n # Cleanup and stop\n carb.log_warn(\"Template Simulation App is closing.\")\n self.timeline.stop()\n simulation_app.close()\n\ndef main():\n\n # Instantiate the template app\n template_app = Template()\n\n # Run the application loop\n template_app.run()\n\nif __name__ == \"__main__\":\n main()\n"},"size":{"kind":"number","value":4001,"string":"4,001"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":34.105262858725766,"string":"34.105263"},"max_line_length":{"kind":"number","value":121,"string":"121"},"alphanum_fraction":{"kind":"number","value":0.6525868531235725,"string":"0.652587"}}},{"rowIdx":42,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/examples/8_camera_vehicle.py"},"content":{"kind":"string","value":"#!/usr/bin/env python\n\"\"\"\n| File: 8_camera_vehicle.py\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved.\n| Description: This files serves as an example on how to build an app that makes use of the Pegasus API to run a simulation\nwith a single vehicle equipped with a camera, producing rgb and camera info ROS2 topics.\n\"\"\"\n\n# Imports to start Isaac Sim from this script\nimport carb\nfrom omni.isaac.kit import SimulationApp\n\n# Start Isaac Sim's simulation environment\n# Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash\n# as this is the object that will load all the extensions and load the actual simulator.\nsimulation_app = SimulationApp({\"headless\": False})\n\n# -----------------------------------\n# The actual script should start here\n# -----------------------------------\nimport omni.timeline\nfrom omni.isaac.core.world import World\nfrom omni.isaac.core.utils.extensions import disable_extension, enable_extension\n\n# Enable/disable ROS bridge extensions to keep only ROS2 Bridge\ndisable_extension(\"omni.isaac.ros_bridge\")\nenable_extension(\"omni.isaac.ros2_bridge\")\n\n# Import the Pegasus API for simulating drones\nfrom pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend, MavlinkBackendConfig\nfrom pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\nfrom pegasus.simulator.logic.graphs import ROS2Camera\n\n# Auxiliary scipy and numpy modules\nfrom scipy.spatial.transform import Rotation\n\nclass PegasusApp:\n \"\"\"\n A Template class that serves as an example on how to build a simple Isaac Sim standalone App.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Method that initializes the PegasusApp and is used to setup the simulation environment.\n \"\"\"\n\n # Acquire the timeline that will be used to start/stop the simulation\n self.timeline = omni.timeline.get_timeline_interface()\n\n # Start the Pegasus Interface\n self.pg = PegasusInterface()\n\n # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics,\n # spawning asset primitives, etc.\n self.pg._world = World(**self.pg._world_settings)\n self.world = self.pg.world\n\n # Launch one of the worlds provided by NVIDIA\n self.pg.load_environment(SIMULATION_ENVIRONMENTS[\"Curved Gridroom\"])\n\n # Create the vehicle\n # Try to spawn the selected robot in the world to the specified namespace\n config_multirotor = MultirotorConfig()\n # Create the multirotor configuration\n mavlink_config = MavlinkBackendConfig({\n \"vehicle_id\": 0,\n \"px4_autolaunch\": True,\n \"px4_dir\": \"/home/marcelo/PX4-Autopilot\",\n \"px4_vehicle_model\": 'iris'\n })\n config_multirotor.backends = [MavlinkBackend(mavlink_config)]\n\n # Create camera graph for the existing Camera prim on the Iris model, which can be found \n # at the prim path `/World/quadrotor/body/Camera`. The camera prim path is the local path from the vehicle's prim path\n # to the camera prim, to which this graph will be connected. All ROS2 topics published by this graph will have \n # namespace `quadrotor` and frame_id `Camera` followed by the selected camera types (`rgb`, `camera_info`).\n config_multirotor.graphs = [ROS2Camera(\"body/Camera\", config={\"types\": ['rgb', 'camera_info']})]\n\n Multirotor(\n \"/World/quadrotor\",\n ROBOTS['Iris'],\n 0,\n [0.0, 0.0, 0.07],\n Rotation.from_euler(\"XYZ\", [0.0, 0.0, 0.0], degrees=True).as_quat(),\n config=config_multirotor,\n )\n\n # Reset the simulation environment so that all articulations (aka robots) are initialized\n self.world.reset()\n\n # Auxiliar variable for the timeline callback example\n self.stop_sim = False\n\n def run(self):\n \"\"\"\n Method that implements the application main loop, where the physics steps are executed.\n \"\"\"\n\n # Start the simulation\n self.timeline.play()\n\n # The \"infinite\" loop\n while simulation_app.is_running() and not self.stop_sim:\n # Update the UI of the app and perform the physics step\n self.world.step(render=True)\n\n # Cleanup and stop\n carb.log_warn(\"PegasusApp Simulation App is closing.\")\n self.timeline.stop()\n simulation_app.close()\n\ndef main():\n\n # Instantiate the template app\n pg_app = PegasusApp()\n\n # Run the application loop\n pg_app.run()\n\nif __name__ == \"__main__\":\n main()\n"},"size":{"kind":"number","value":4878,"string":"4,878"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":38.031999695744005,"string":"38.032"},"max_line_length":{"kind":"number","value":126,"string":"126"},"alphanum_fraction":{"kind":"number","value":0.6775317751788578,"string":"0.677532"}}},{"rowIdx":43,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/examples/utils/nonlinear_controller.py"},"content":{"kind":"string","value":"#!/usr/bin/env python\n\"\"\"\n| File: nonlinear_controller.py\n| Author: Marcelo Jacinto and Joao Pinto (marcelo.jacinto@tecnico.ulisboa.pt, joao.s.pinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: This files serves as an example on how to use the control backends API to create a custom controller \nfor the vehicle from scratch and use it to perform a simulation, without using PX4 nor ROS. In this controller, we\nprovide a quick way of following a given trajectory specified in csv files or track an hard-coded trajectory based\non exponentials! NOTE: This is just an example, to demonstrate the potential of the API. A much more flexible solution\ncan be achieved\n\"\"\"\n\n# Imports to be able to log to the terminal with fancy colors\nimport carb\n\n# Imports from the Pegasus library\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.backends import Backend\n\n# Auxiliary scipy and numpy modules\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\nclass NonlinearController(Backend):\n \"\"\"A nonlinear controller class. It implements a nonlinear controller that allows a vehicle to track\n aggressive trajectories. This controlers is well described in the papers\n \n [1] J. Pinto, B. J. Guerreiro and R. Cunha, \"Planning Parcel Relay Manoeuvres for Quadrotors,\" \n 2021 International Conference on Unmanned Aircraft Systems (ICUAS), Athens, Greece, 2021, \n pp. 137-145, doi: 10.1109/ICUAS51884.2021.9476757.\n [2] D. Mellinger and V. Kumar, \"Minimum snap trajectory generation and control for quadrotors,\" \n 2011 IEEE International Conference on Robotics and Automation, Shanghai, China, 2011, \n pp. 2520-2525, doi: 10.1109/ICRA.2011.5980409.\n \"\"\"\n\n def __init__(self, \n trajectory_file: str = None, \n results_file: str=None, \n reverse=False, \n Kp=[10.0, 10.0, 10.0],\n Kd=[8.5, 8.5, 8.5],\n Ki=[1.50, 1.50, 1.50],\n Kr=[3.5, 3.5, 3.5],\n Kw=[0.5, 0.5, 0.5]):\n\n # The current rotor references [rad/s]\n self.input_ref = [0.0, 0.0, 0.0, 0.0]\n\n # The current state of the vehicle expressed in the inertial frame (in ENU)\n self.p = np.zeros((3,)) # The vehicle position\n self.R: Rotation = Rotation.identity() # The vehicle attitude\n self.w = np.zeros((3,)) # The angular velocity of the vehicle\n self.v = np.zeros((3,)) # The linear velocity of the vehicle in the inertial frame\n self.a = np.zeros((3,)) # The linear acceleration of the vehicle in the inertial frame\n\n # Define the control gains matrix for the outer-loop\n self.Kp = np.diag(Kp)\n self.Kd = np.diag(Kd)\n self.Ki = np.diag(Ki)\n self.Kr = np.diag(Kr)\n self.Kw = np.diag(Kw)\n\n self.int = np.array([0.0, 0.0, 0.0])\n\n # Define the dynamic parameters for the vehicle\n self.m = 1.50 # Mass in Kg\n self.g = 9.81 # The gravity acceleration ms^-2\n\n # Read the target trajectory from a CSV file inside the trajectories directory\n # if a trajectory is provided. Otherwise, just perform the hard-coded trajectory provided with this controller\n if trajectory_file is not None:\n self.trajectory = self.read_trajectory_from_csv(trajectory_file)\n self.index = 0\n self.max_index, _ = self.trajectory.shape\n self.total_time = 0.0\n # Use the built-in trajectory hard-coded for this controller\n else:\n # Set the initial time for starting when using the built-in trajectory (the time is also used in this case\n # as the parametric value)\n self.total_time = -5.0\n # Signal that we will not used a received trajectory\n self.trajectory = None\n self.max_index = 1\n\n self.reverse = reverse\n\n # Auxiliar variable, so that we only start sending motor commands once we get the state of the vehicle\n self.reveived_first_state = False\n\n # Lists used for analysing performance statistics\n self.results_files = results_file\n self.time_vector = []\n self.desired_position_over_time = []\n self.position_over_time = []\n self.position_error_over_time = []\n self.velocity_error_over_time = []\n self.atittude_error_over_time = []\n self.attitude_rate_error_over_time = []\n\n def read_trajectory_from_csv(self, file_name: str):\n \"\"\"Auxiliar method used to read the desired trajectory from a CSV file\n\n Args:\n file_name (str): A string with the name of the trajectory inside the trajectories directory\n\n Returns:\n np.ndarray: A numpy matrix with the trajectory desired states over time\n \"\"\"\n\n # Read the trajectory to a pandas frame\n return np.flip(np.genfromtxt(file_name, delimiter=','), axis=0)\n\n\n def start(self):\n \"\"\"\n Reset the control and trajectory index\n \"\"\"\n self.reset_statistics()\n \n\n def stop(self):\n \"\"\"\n Stopping the controller. Saving the statistics data for plotting later\n \"\"\"\n\n # Check if we should save the statistics to some file or not\n if self.results_files is None:\n return\n \n statistics = {}\n statistics[\"time\"] = np.array(self.time_vector)\n statistics[\"p\"] = np.vstack(self.position_over_time)\n statistics[\"desired_p\"] = np.vstack(self.desired_position_over_time)\n statistics[\"ep\"] = np.vstack(self.position_error_over_time)\n statistics[\"ev\"] = np.vstack(self.velocity_error_over_time)\n statistics[\"er\"] = np.vstack(self.atittude_error_over_time)\n statistics[\"ew\"] = np.vstack(self.attitude_rate_error_over_time)\n np.savez(self.results_files, **statistics)\n carb.log_warn(\"Statistics saved to: \" + self.results_files)\n\n self.reset_statistics()\n\n def update_sensor(self, sensor_type: str, data):\n \"\"\"\n Do nothing. For now ignore all the sensor data and just use the state directly for demonstration purposes. \n This is a callback that is called at every physics step.\n\n Args:\n sensor_type (str): The name of the sensor providing the data\n data (dict): A dictionary that contains the data produced by the sensor\n \"\"\"\n pass\n\n def update_state(self, state: State):\n \"\"\"\n Method that updates the current state of the vehicle. This is a callback that is called at every physics step\n\n Args:\n state (State): The current state of the vehicle.\n \"\"\"\n self.p = state.position\n self.R = Rotation.from_quat(state.attitude)\n self.w = state.angular_velocity\n self.v = state.linear_velocity\n\n self.reveived_first_state = True\n\n def input_reference(self):\n \"\"\"\n Method that is used to return the latest target angular velocities to be applied to the vehicle\n\n Returns:\n A list with the target angular velocities for each individual rotor of the vehicle\n \"\"\"\n return self.input_ref\n\n def update(self, dt: float):\n \"\"\"Method that implements the nonlinear control law and updates the target angular velocities for each rotor. \n This method will be called by the simulation on every physics step\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n \n if self.reveived_first_state == False:\n return\n\n # -------------------------------------------------\n # Update the references for the controller to track\n # -------------------------------------------------\n self.total_time += dt\n \n\n # Check if we need to update to the next trajectory index\n if self.index < self.max_index - 1 and self.total_time >= self.trajectory[self.index + 1, 0]:\n self.index += 1\n\n # Update using an external trajectory\n if self.trajectory is not None:\n # the target positions [m], velocity [m/s], accelerations [m/s^2], jerk [m/s^3], yaw-angle [rad], yaw-rate [rad/s]\n p_ref = np.array([self.trajectory[self.index, 1], self.trajectory[self.index, 2], self.trajectory[self.index, 3]])\n v_ref = np.array([self.trajectory[self.index, 4], self.trajectory[self.index, 5], self.trajectory[self.index, 6]])\n a_ref = np.array([self.trajectory[self.index, 7], self.trajectory[self.index, 8], self.trajectory[self.index, 9]])\n j_ref = np.array([self.trajectory[self.index, 10], self.trajectory[self.index, 11], self.trajectory[self.index, 12]])\n yaw_ref = self.trajectory[self.index, 13]\n yaw_rate_ref = self.trajectory[self.index, 14]\n # Or update the reference using the built-in trajectory\n else:\n s = 0.6\n p_ref = self.pd(self.total_time, s, self.reverse)\n v_ref = self.d_pd(self.total_time, s, self.reverse)\n a_ref = self.dd_pd(self.total_time, s, self.reverse)\n j_ref = self.ddd_pd(self.total_time, s, self.reverse)\n yaw_ref = self.yaw_d(self.total_time, s)\n yaw_rate_ref = self.d_yaw_d(self.total_time, s)\n\n # -------------------------------------------------\n # Start the controller implementation\n # -------------------------------------------------\n\n # Compute the tracking errors\n ep = self.p - p_ref\n ev = self.v - v_ref\n self.int = self.int + (ep * dt)\n ei = self.int\n\n # Compute F_des term\n 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)\n\n # Get the current axis Z_B (given by the last column of the rotation matrix)\n Z_B = self.R.as_matrix()[:,2]\n\n # Get the desired total thrust in Z_B direction (u_1)\n u_1 = F_des @ Z_B\n\n # Compute the desired body-frame axis Z_b\n Z_b_des = F_des / np.linalg.norm(F_des)\n\n # Compute X_C_des \n X_c_des = np.array([np.cos(yaw_ref), np.sin(yaw_ref), 0.0])\n\n # Compute Y_b_des\n Z_b_cross_X_c = np.cross(Z_b_des, X_c_des)\n Y_b_des = Z_b_cross_X_c / np.linalg.norm(Z_b_cross_X_c)\n\n # Compute X_b_des\n X_b_des = np.cross(Y_b_des, Z_b_des)\n\n # Compute the desired rotation R_des = [X_b_des | Y_b_des | Z_b_des]\n R_des = np.c_[X_b_des, Y_b_des, Z_b_des]\n R = self.R.as_matrix()\n\n # Compute the rotation error\n e_R = 0.5 * self.vee((R_des.T @ R) - (R.T @ R_des))\n\n # Compute an approximation of the current vehicle acceleration in the inertial frame (since we cannot measure it directly)\n self.a = (u_1 * Z_B) / self.m - np.array([0.0, 0.0, self.g])\n\n # Compute the desired angular velocity by projecting the angular velocity in the Xb-Yb plane\n # projection of angular velocity on xB − yB plane\n # see eqn (7) from [2].\n hw = (self.m / u_1) * (j_ref - np.dot(Z_b_des, j_ref) * Z_b_des) \n \n # desired angular velocity\n w_des = np.array([-np.dot(hw, Y_b_des), \n np.dot(hw, X_b_des), \n yaw_rate_ref * Z_b_des[2]])\n\n # Compute the angular velocity error\n e_w = self.w - w_des\n\n # Compute the torques to apply on the rigid body\n tau = -(self.Kr @ e_R) - (self.Kw @ e_w)\n\n # Use the allocation matrix provided by the Multirotor vehicle to convert the desired force and torque\n # to angular velocity [rad/s] references to give to each rotor\n if self.vehicle:\n self.input_ref = self.vehicle.force_and_torques_to_velocities(u_1, tau)\n\n # ----------------------------\n # Statistics to save for later\n # ----------------------------\n self.time_vector.append(self.total_time)\n self.position_over_time.append(self.p)\n self.desired_position_over_time.append(p_ref)\n self.position_error_over_time.append(ep)\n self.velocity_error_over_time.append(ev)\n self.atittude_error_over_time.append(e_R)\n self.attitude_rate_error_over_time.append(e_w)\n\n @staticmethod\n def vee(S):\n \"\"\"Auxiliary function that computes the 'v' map which takes elements from so(3) to R^3.\n\n Args:\n S (np.array): A matrix in so(3)\n \"\"\"\n return np.array([-S[1,2], S[0,2], -S[0,1]])\n \n def reset_statistics(self):\n\n self.index = 0\n # If we received an external trajectory, reset the time to 0.0\n if self.trajectory is not None:\n self.total_time = 0.0\n # if using the internal trajectory, make the parametric value start at -5.0\n else:\n self.total_time = -5.0\n\n # Reset the lists used for analysing performance statistics\n self.time_vector = []\n self.desired_position_over_time = []\n self.position_over_time = []\n self.position_error_over_time = []\n self.velocity_error_over_time = []\n self.atittude_error_over_time = []\n self.attitude_rate_error_over_time = []\n\n # ---------------------------------------------------\n # Definition of an exponential trajectory for example\n # This can be used as a reference if not trajectory file is passed\n # as an argument to the constructor of this class\n # ---------------------------------------------------\n\n def pd(self, t, s, reverse=False):\n \"\"\"The desired position of the built-in trajectory\n\n Args:\n t (float): The parametric value that guides the equation\n s (float): How steep and agressive the curve is\n reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False.\n\n Returns:\n np.ndarray: A 3x1 array with the x, y ,z desired [m]\n \"\"\"\n\n x = t\n z = 1 / s * np.exp(-0.5 * np.power(t/s, 2)) + 1.0\n y = 1 / s * np.exp(-0.5 * np.power(t/s, 2))\n\n if reverse == True:\n y = -1 / s * np.exp(-0.5 * np.power(t/s, 2)) + 4.5\n\n return np.array([x,y,z])\n\n def d_pd(self, t, s, reverse=False):\n \"\"\"The desired velocity of the built-in trajectory\n\n Args:\n t (float): The parametric value that guides the equation\n s (float): How steep and agressive the curve is\n reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False.\n\n Returns:\n np.ndarray: A 3x1 array with the d_x, d_y ,d_z desired [m/s]\n \"\"\"\n\n x = 1.0\n y = -(t * np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,3)\n z = -(t * np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,3)\n\n if reverse == True:\n y = (t * np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,3)\n\n return np.array([x,y,z])\n\n def dd_pd(self, t, s, reverse=False):\n \"\"\"The desired acceleration of the built-in trajectory\n\n Args:\n t (float): The parametric value that guides the equation\n s (float): How steep and agressive the curve is\n reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False.\n\n Returns:\n np.ndarray: A 3x1 array with the dd_x, dd_y ,dd_z desired [m/s^2]\n \"\"\"\n\n x = 0.0\n 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)\n 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)\n\n if reverse == True:\n 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)\n\n return np.array([x,y,z])\n\n def ddd_pd(self, t, s, reverse=False):\n \"\"\"The desired jerk of the built-in trajectory\n\n Args:\n t (float): The parametric value that guides the equation\n s (float): How steep and agressive the curve is\n reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False.\n\n Returns:\n np.ndarray: A 3x1 array with the ddd_x, ddd_y ,ddd_z desired [m/s^3]\n \"\"\"\n x = 0.0\n 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)\n 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)\n\n if reverse == True:\n 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)\n\n return np.array([x,y,z])\n\n def yaw_d(self, t, s):\n \"\"\"The desired yaw of the built-in trajectory\n\n Args:\n t (float): The parametric value that guides the equation\n s (float): How steep and agressive the curve is\n reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False.\n\n Returns:\n np.ndarray: A float with the desired yaw in rad\n \"\"\"\n return 0.0\n \n def d_yaw_d(self, t, s):\n \"\"\"The desired yaw_rate of the built-in trajectory\n\n Args:\n t (float): The parametric value that guides the equation\n s (float): How steep and agressive the curve is\n reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False.\n\n Returns:\n np.ndarray: A float with the desired yaw_rate in rad/s\n \"\"\"\n return 0.0"},"size":{"kind":"number","value":18171,"string":"18,171"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":41.06481471975737,"string":"41.064815"},"max_line_length":{"kind":"number","value":149,"string":"149"},"alphanum_fraction":{"kind":"number","value":0.5871443508564667,"string":"0.587144"}}},{"rowIdx":44,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/setup.py"},"content":{"kind":"string","value":"\"\"\"\n| File: setup.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: File that defines the installation requirements for this python package.\n\"\"\"\nimport os\nimport toml\n\nfrom setuptools import setup\n\n# Obtain the extension data from the extension.toml file\nEXTENSION_PATH = os.path.dirname(os.path.realpath(__file__))\n# Read the extension.toml file\nEXTENSION_TOML_DATA = toml.load(os.path.join(EXTENSION_PATH, \"config\", \"extension.toml\"))\n\n# Minimum dependencies required prior to installation\nINSTALL_REQUIRES = [\n # generic\n \"numpy\",\n \"pymavlink\",\n \"scipy\",\n \"pyyaml\",\n]\n\n# Installation operation\nsetup(\n name=\"pegasus-simulator\",\n author=\"Marcelo Jacinto\",\n maintainer=\"Marcelo Jacinto\",\n maintainer_email=\"marcelo.jacinto@tecnico.ulisboa.pt\",\n url=EXTENSION_TOML_DATA[\"package\"][\"repository\"],\n version=EXTENSION_TOML_DATA[\"package\"][\"version\"],\n description=EXTENSION_TOML_DATA[\"package\"][\"description\"],\n keywords=EXTENSION_TOML_DATA[\"package\"][\"keywords\"],\n license=\"BSD-3-Clause\",\n include_package_data=True,\n python_requires=\">=3.7\",\n install_requires=INSTALL_REQUIRES,\n packages=[\"pegasus.simulator\"],\n classifiers=[\"Natural Language :: English\", \"Programming Language :: Python :: 3.7\"],\n zip_safe=False,\n)"},"size":{"kind":"number","value":1389,"string":"1,389"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":31.325580666846964,"string":"31.325581"},"max_line_length":{"kind":"number","value":89,"string":"89"},"alphanum_fraction":{"kind":"number","value":0.7127429800484211,"string":"0.712743"}}},{"rowIdx":45,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/extension.py"},"content":{"kind":"string","value":"\"\"\"\n| File: extension.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| 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.\n\"\"\"\n__all__ = [\"Pegasus_SimulatorExtension\"]\n\n# Python garbage collenction and asyncronous API\nimport gc\nimport asyncio\nfrom functools import partial\nfrom threading import Timer\n\n# Omniverse general API\nimport pxr\nimport carb\nimport omni.ext\nimport omni.usd\nimport omni.kit.ui\nimport omni.kit.app\nimport omni.ui as ui\n\nfrom omni.kit.viewport.utility import get_active_viewport\n\n# Pegasus Extension Files and API\nfrom pegasus.simulator.params import MENU_PATH, WINDOW_TITLE\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\n\n# Setting up the UI for the extension's Widget\nfrom pegasus.simulator.ui.ui_window import WidgetWindow\nfrom pegasus.simulator.ui.ui_delegate import UIDelegate\n\n# Any class derived from `omni.ext.IExt` in top level module (defined in `python.modules` of `extension.toml`) will be\n# instantiated when extension gets enabled and `on_startup(ext_id)` will be called. Later when extension gets disabled\n# on_shutdown() is called.\nclass Pegasus_SimulatorExtension(omni.ext.IExt):\n # ext_id is current extension id. It can be used with extension manager to query additional information, like where\n # this extension is located on filesystem.\n def on_startup(self, ext_id):\n\n carb.log_info(\"Pegasus Simulator is starting up\")\n\n # Save the extension id\n self._ext_id = ext_id\n\n # Create the UI of the app and its manager\n self.ui_delegate = None\n self.ui_window = None\n\n # Start the extension backend\n self._pegasus_sim = PegasusInterface()\n\n # Check if we already have a stage loaded (when using autoload feature, it might not be ready yet)\n # This is a limitation of the simulator, and we are doing this to make sure that the \n # extension does no crash when using the GUI with autoload feature\n # If autoload was not enabled, and we are enabling the extension from the Extension widget, then \n # we will always have a state open, and the auxiliary timer will never run\n if omni.usd.get_context().get_stage_state() != omni.usd.StageState.CLOSED:\n self._pegasus_sim.initialize_world()\n else:\n # We need to create a timer to check until the window is properly open and the stage created. This is a limitation\n # of the current Isaac Sim simulator and the way it loads extensions :(\n self.autoload_helper()\n\n # Add the ability to show the window if the system requires it (QuickLayout feature)\n ui.Workspace.set_show_window_fn(WINDOW_TITLE, partial(self.show_window, None))\n\n # Add the extension to the editor menu inside isaac sim\n editor_menu = omni.kit.ui.get_editor_menu()\n if editor_menu:\n self._menu = editor_menu.add_item(MENU_PATH, self.show_window, toggle=True, value=True)\n\n # Show the window (It call the self.show_window)\n ui.Workspace.show_window(WINDOW_TITLE, show=True)\n\n def autoload_helper(self):\n \n # Check if we already have a viewport and a camera of interest\n 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\":\n self._pegasus_sim.initialize_world()\n else:\n Timer(1.0, self.autoload_helper).start()\n\n def show_window(self, menu, show):\n \"\"\"\n Method that controls whether a widget window is created or not\n \"\"\"\n\n if show == True:\n\n # Create a window and its delegate\n self.ui_delegate = UIDelegate()\n self.ui_window = WidgetWindow(self.ui_delegate)\n self.ui_window.set_visibility_changed_fn(self._visibility_changed_fn)\n\n # If we have a window and we are not supposed to show it, then change its visibility\n elif self.ui_window:\n self.ui_window.visible = False\n\n def _visibility_changed_fn(self, visible):\n \"\"\"\n This method is invoked when the user pressed the \"X\" to close the extension window\n \"\"\"\n\n # Update the Isaac sim menu visibility\n self._set_menu(visible)\n\n if not visible:\n # Destroy the window, because we create a new one in the show window method\n asyncio.ensure_future(self._destroy_window_async())\n\n def _set_menu(self, visible):\n \"\"\"\n Method that updates the isaac sim ui menu to create the Widget window on and off\n \"\"\"\n editor_menu = omni.kit.ui.get_editor_menu()\n if editor_menu:\n editor_menu.set_value(MENU_PATH, visible)\n\n async def _destroy_window_async(self):\n\n # Wait one frame before it gets destructed (from NVidia example)\n await omni.kit.app.get_app().next_update_async()\n\n # Destroy the window UI if it exists\n if self.ui_window:\n self.ui_window.destroy()\n self.ui_window = None\n\n def on_shutdown(self):\n \"\"\"\n Callback called when the extension is shutdown\n \"\"\"\n carb.log_info(\"Pegasus Isaac extension shutdown\")\n\n # Destroy the isaac sim menu object\n self._menu = None\n\n # Destroy the window\n if self.ui_window:\n self.ui_window.destroy()\n self.ui_window = None\n\n # Destroy the UI delegate\n if self.ui_delegate:\n self.ui_delegate = None\n\n # De-register the function taht shows the window from the isaac sim ui\n ui.Workspace.set_show_window_fn(WINDOW_TITLE, None)\n\n editor_menu = omni.kit.ui.get_editor_menu()\n if editor_menu:\n editor_menu.remove_item(MENU_PATH)\n\n # Call the garbage collector\n gc.collect()\n"},"size":{"kind":"number","value":6081,"string":"6,081"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":37.493670648774234,"string":"37.493671"},"max_line_length":{"kind":"number","value":193,"string":"193"},"alphanum_fraction":{"kind":"number","value":0.666995559831114,"string":"0.666996"}}},{"rowIdx":46,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/__init__.py"},"content":{"kind":"string","value":"\"\"\"\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n\n__author__ = \"Marcelo Jacinto\"\n__email__ = \"marcelo.jacinto@tecnico.ulisboa.pt\"\n\nfrom .extension import Pegasus_SimulatorExtension"},"size":{"kind":"number","value":285,"string":"285"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":30.777774358025074,"string":"30.777774"},"max_line_length":{"kind":"number","value":82,"string":"82"},"alphanum_fraction":{"kind":"number","value":0.7403508745952601,"string":"0.740351"}}},{"rowIdx":47,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/params.py"},"content":{"kind":"string","value":"\"\"\"\n| File: params.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: File that defines the base configurations for the Pegasus Simulator.\n\"\"\"\nimport os\nfrom pathlib import Path\n\nimport omni.isaac.core.utils.nucleus as nucleus\n\n# Extension configuration\nEXTENSION_NAME = \"Pegasus Simulator\"\nWINDOW_TITLE = \"Pegasus Simulator\"\nMENU_PATH = \"Window/\" + WINDOW_TITLE\nDOC_LINK = \"https://docs.omniverse.nvidia.com\"\nEXTENSION_OVERVIEW = \"This extension shows how to incorporate drones into Isaac Sim\"\n\n# Get the current directory of where this extension is located\nEXTENSION_FOLDER_PATH = Path(os.path.dirname(os.path.realpath(__file__)))\nROOT = str(EXTENSION_FOLDER_PATH.parent.parent.parent.resolve())\n\n# Get the configurations file path\nCONFIG_FILE = ROOT + \"/pegasus.simulator/config/configs.yaml\"\n\n# Define the Extension Assets Path\nASSET_PATH = ROOT + \"/pegasus.simulator/pegasus/simulator/assets\"\nROBOTS_ASSETS = ASSET_PATH + \"/Robots\"\n\n# Define the built in robots of the extension\nROBOTS = {\"Iris\": ROBOTS_ASSETS + \"/Iris/iris.usd\"} #, \"Flying Cube\": ROBOTS_ASSETS + \"/iris_cube.usda\"}\n\n# Setup the default simulation environments path\nNVIDIA_ASSETS_PATH = str(nucleus.get_assets_root_path())\nISAAC_SIM_ENVIRONMENTS = \"/Isaac/Environments\"\nNVIDIA_SIMULATION_ENVIRONMENTS = {\n \"Default Environment\": \"Grid/default_environment.usd\",\n \"Black Gridroom\": \"Grid/gridroom_black.usd\",\n \"Curved Gridroom\": \"Grid/gridroom_curved.usd\",\n \"Hospital\": \"Hospital/hospital.usd\",\n \"Office\": \"Office/office.usd\",\n \"Simple Room\": \"Simple_Room/simple_room.usd\",\n \"Warehouse\": \"Simple_Warehouse/warehouse.usd\",\n \"Warehouse with Forklifts\": \"Simple_Warehouse/warehouse_with_forklifts.usd\",\n \"Warehouse with Shelves\": \"Simple_Warehouse/warehouse_multiple_shelves.usd\",\n \"Full Warehouse\": \"Simple_Warehouse/full_warehouse.usd\",\n \"Flat Plane\": \"Terrains/flat_plane.usd\",\n \"Rough Plane\": \"Terrains/rough_plane.usd\",\n \"Slope Plane\": \"Terrains/slope.usd\",\n \"Stairs Plane\": \"Terrains/stairs.usd\",\n}\n\nOMNIVERSE_ENVIRONMENTS = {\n \"Exhibition Hall\": \"omniverse://localhost/NVIDIA/Assets/Scenes/Templates/Interior/ZetCG_ExhibitionHall.usd\"\n}\n\nSIMULATION_ENVIRONMENTS = {}\n\n# Add the Isaac Sim assets to the list\nfor asset in NVIDIA_SIMULATION_ENVIRONMENTS:\n SIMULATION_ENVIRONMENTS[asset] = (\n NVIDIA_ASSETS_PATH + ISAAC_SIM_ENVIRONMENTS + \"/\" + NVIDIA_SIMULATION_ENVIRONMENTS[asset]\n )\n\n# Add the omniverse assets to the list\nfor asset in OMNIVERSE_ENVIRONMENTS:\n SIMULATION_ENVIRONMENTS[asset] = OMNIVERSE_ENVIRONMENTS[asset]\n\n# Define the default settings for the simulation environment\nDEFAULT_WORLD_SETTINGS = {\"physics_dt\": 1.0 / 250.0, \"stage_units_in_meters\": 1.0, \"rendering_dt\": 1.0 / 60.0}\n\n# Define where the thumbnail of the vehicle is located\nTHUMBNAIL = ROBOTS_ASSETS + \"/Iris/iris_thumbnail.png\"\n\n# Define where the thumbail of the world is located\nWORLD_THUMBNAIL = ASSET_PATH + \"/Worlds/Empty_thumbnail.png\"\n"},"size":{"kind":"number","value":3070,"string":"3,070"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":38.883116378141345,"string":"38.883116"},"max_line_length":{"kind":"number","value":111,"string":"111"},"alphanum_fraction":{"kind":"number","value":0.7394136805409076,"string":"0.739414"}}},{"rowIdx":48,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/dynamics_parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\n\n# Sensors that can be used with the vehicles\nfrom pegasus.simulator.parser import Parser\nfrom pegasus.simulator.logic.dynamics import LinearDrag\n\n\nclass DynamicsParser(Parser):\n def __init__(self):\n\n # Dictionary of available sensors to instantiate\n self.dynamics = {\"linear_drag\": LinearDrag}\n\n def parse(self, data_type: str, data_dict):\n\n # Get the class of the sensor\n dynamics_cls = self.dynamics[data_type]\n\n # Create an instance of that sensor\n return dynamics_cls(data_dict)\n"},"size":{"kind":"number","value":635,"string":"635"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":25.49999893750004,"string":"25.499999"},"max_line_length":{"kind":"number","value":56,"string":"56"},"alphanum_fraction":{"kind":"number","value":0.6992125973240747,"string":"0.699213"}}},{"rowIdx":49,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\n\n\nclass Parser:\n def __init__(self):\n pass\n\n def parse(self, data_type: str, data_dict):\n pass\n"},"size":{"kind":"number","value":218,"string":"218"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":15.846152627219029,"string":"15.846153"},"max_line_length":{"kind":"number","value":47,"string":"47"},"alphanum_fraction":{"kind":"number","value":0.6284403640897231,"string":"0.62844"}}},{"rowIdx":50,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/thrusters_parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\n\n# Sensors that can be used with the vehicles\nfrom pegasus.simulator.parser import Parser\nfrom pegasus.simulator.logic.thrusters import QuadraticThrustCurve\n\n\nclass ThrustersParser(Parser):\n def __init__(self):\n\n # Dictionary of available thrust curves to instantiate\n self.thrust_curves = {\"quadratic_thrust_curve\": QuadraticThrustCurve}\n\n def parse(self, data_type: str, data_dict):\n\n # Get the class of the sensor\n thrust_curve_cls = self.thrust_curves[data_type]\n\n # Create an instance of that sensor\n return thrust_curve_cls(data_dict)\n"},"size":{"kind":"number","value":692,"string":"692"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":27.874998838541714,"string":"27.874999"},"max_line_length":{"kind":"number","value":77,"string":"77"},"alphanum_fraction":{"kind":"number","value":0.7153179180414481,"string":"0.715318"}}},{"rowIdx":51,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/vehicle_parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\nimport carb\n\n# Sensors that can be used with the vehicles\nfrom pegasus.simulator.parser import Parser, SensorParser, ThrustersParser, DynamicsParser, BackendsParser\nfrom pegasus.simulator.logic.vehicles import MultirotorConfig\n\n\nclass VehicleParser(Parser):\n def __init__(self):\n\n # Initialize the Parser object\n super().__init__()\n\n # Initialize Parsers for the sensors, dynamics and backends for control and communications\n self.sensor_parser = SensorParser()\n self.thrusters_parser = ThrustersParser()\n self.dynamics_parser = DynamicsParser()\n self.backends_parser = BackendsParser()\n\n def parse(self, data_type: str, data_dict={}):\n\n # Get the USD model associated with the vehicle\n usd_model = data_dict.get(\"usd_model\", \"\")\n\n # Get the model thumbnail of the vehicle\n thumbnail = data_dict.get(\"thumbnail\", \"\")\n\n # ---------------------------------------\n # Generate the sensors for the multirotor\n # ---------------------------------------\n sensors = []\n sensors_config = data_dict.get(\"sensors\", {})\n\n for sensor_name in sensors_config:\n sensor = self.sensor_parser.parse(sensor_name, sensors_config[sensor_name])\n if sensor is not None:\n sensors.append(sensor)\n\n # -----------------------------------------\n # Generate the thrusters for the multirotor\n # -----------------------------------------\n thrusters = None\n thrusters_config = data_dict.get(\"thrusters\", {})\n\n # Note: if a dictionary/yaml file contains more than one thrust curve configuration,\n # only the last one will be kept\n for thrust_curve_name in thrusters_config:\n curve = self.thrusters_parser.parse(thrust_curve_name, thrusters_config[thrust_curve_name])\n if curve is not None:\n thrusters = curve\n\n # ----------------------------------------\n # Generate the dynamics for the multirotor\n # ----------------------------------------\n dynamics = None\n dynamics_config = data_dict.get(\"drag\", {})\n\n for dynamics_name in dynamics_config:\n carb.log_warn(dynamics_config[dynamics_name])\n dynamic = self.dynamics_parser.parse(dynamics_name, dynamics_config[dynamics_name])\n if dynamic is not None:\n dynamics = dynamic\n\n # ----------------------------------------\n # Generate the backends for the multirotor\n # ----------------------------------------\n backends = []\n backends_config = data_dict.get(\"backends\", {})\n\n for backends_name in backends_config:\n backend = self.backends_parser.parse(backends_name, backends_config[backends_name])\n if backend is not None:\n backends.append(backend)\n\n # Create a Multirotor config from the parsed data\n multirotor_configuration = MultirotorConfig()\n multirotor_configuration.usd_file = usd_model\n multirotor_configuration.thrust_curve = thrusters\n multirotor_configuration.drag = dynamics\n multirotor_configuration.sensors = sensors\n multirotor_configuration.backends = backends\n\n return multirotor_configuration\n"},"size":{"kind":"number","value":3406,"string":"3,406"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":37.71590866231922,"string":"37.715909"},"max_line_length":{"kind":"number","value":106,"string":"106"},"alphanum_fraction":{"kind":"number","value":0.5775102758140017,"string":"0.57751"}}},{"rowIdx":52,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/__init__.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\nfrom .parser import Parser\nfrom .sensor_parser import SensorParser\nfrom .thrusters_parser import ThrustersParser\nfrom .dynamics_parser import DynamicsParser\nfrom .backends_parser import BackendsParser\nfrom .graphs_parser import GraphParser\n"},"size":{"kind":"number","value":343,"string":"343"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":30.27272452066141,"string":"30.272725"},"max_line_length":{"kind":"number","value":45,"string":"45"},"alphanum_fraction":{"kind":"number","value":0.8192419801188281,"string":"0.819242"}}},{"rowIdx":53,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/sensor_parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\n\n# Sensors that can be used with the vehicles\nfrom pegasus.simulator.parser import Parser\nfrom pegasus.simulator.logic.sensors import Barometer, GPS, IMU, Magnetometer\n\n\nclass SensorParser(Parser):\n def __init__(self):\n\n # Dictionary of available sensors to instantiate\n self.sensors = {\"barometer\": Barometer, \"gps\": GPS, \"imu\": IMU, \"magnetometer\": Magnetometer}\n\n def parse(self, data_type: str, data_dict):\n\n # Get the class of the sensor\n sensor_cls = self.sensors[data_type]\n\n # Create an instance of that sensor\n return sensor_cls(data_dict)\n"},"size":{"kind":"number","value":700,"string":"700"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":28.20833215798616,"string":"28.208332"},"max_line_length":{"kind":"number","value":101,"string":"101"},"alphanum_fraction":{"kind":"number","value":0.6942857132938776,"string":"0.694286"}}},{"rowIdx":54,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/backends_parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\n\n# Sensors that can be used with the vehicles\nfrom pegasus.simulator.parser import Parser\nfrom pegasus.simulator.logic.backends import MavlinkBackendConfig, MavlinkBackend, ROS2Backend\n\n\nclass BackendsParser(Parser):\n # TODO - improve the structure of the backends in order to clean this parser\n\n def __init__(self):\n\n # Dictionary of available sensors to instantiate\n self.backends = {\"mavlink\": MavlinkBackendConfig, \"ros2\": ROS2Backend}\n\n def parse(self, data_type: str, data_dict):\n\n # Get the class of the sensor\n backends_cls = self.backends[data_type]\n\n if backends_cls == MavlinkBackendConfig:\n return MavlinkBackend(backends_cls(data_dict))\n\n # Create an instance of that sensor\n return backends_cls(data_dict)\n"},"size":{"kind":"number","value":892,"string":"892"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":29.7931024209275,"string":"29.793102"},"max_line_length":{"kind":"number","value":94,"string":"94"},"alphanum_fraction":{"kind":"number","value":0.7096412548098192,"string":"0.709641"}}},{"rowIdx":55,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/graphs_parser.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\n\n# Graphs that can be used with the vehicles\nfrom pegasus.simulator.parser import Parser\nfrom pegasus.simulator.logic.graphs import ROS2Camera\n\n\nclass GraphParser(Parser):\n def __init__(self):\n\n # Dictionary of available graphs to instantiate\n self.graphs = {\n \"ROS2 Camera\": ROS2Camera\n }\n\n def parse(self, data_type: str, data_dict):\n\n # Get the class of the graph\n graph_cls = self.graphs[data_type]\n\n # Create an instance of that graph\n return graph_cls(data_dict)"},"size":{"kind":"number","value":637,"string":"637"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":24.51999901920004,"string":"24.519999"},"max_line_length":{"kind":"number","value":55,"string":"55"},"alphanum_fraction":{"kind":"number","value":0.6671899518568447,"string":"0.66719"}}},{"rowIdx":56,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/ui/ui_window.py"},"content":{"kind":"string","value":"\"\"\"\n| File: ui_window.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of WidgetWindow which contains all the UI code that defines the extension GUI\n\"\"\"\n\n__all__ = [\"WidgetWindow\"]\n\n# External packages\nimport numpy as np\n\n# Omniverse general API\nimport carb\nimport omni.ui as ui\nfrom omni.ui import color as cl\n\nfrom pegasus.simulator.ui.ui_delegate import UIDelegate\nfrom pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS, THUMBNAIL, WORLD_THUMBNAIL, WINDOW_TITLE\n\n\nclass WidgetWindow(ui.Window):\n\n # Design constants for the widgets\n LABEL_PADDING = 120\n BUTTON_HEIGHT = 50\n GENERAL_SPACING = 5\n\n WINDOW_WIDTH = 325\n WINDOW_HEIGHT = 850\n\n BUTTON_SELECTED_STYLE = {\n \"Button\": {\n \"background_color\": 0xFF5555AA,\n \"border_color\": 0xFF5555AA,\n \"border_width\": 2,\n \"border_radius\": 5,\n \"padding\": 5,\n }\n }\n\n BUTTON_BASE_STYLE = {\n \"Button\": {\n \"background_color\": cl(\"#292929\"),\n \"border_color\": cl(\"#292929\"),\n \"border_width\": 2,\n \"border_radius\": 5,\n \"padding\": 5,\n }\n }\n\n def __init__(self, delegate: UIDelegate, **kwargs):\n \"\"\"\n Constructor for the Window UI widget of the extension. Receives as input a UIDelegate that implements\n all the callbacks to handle button clicks, drop-down menu actions, etc. (abstracting the interface between\n the logic of the code and the ui)\n \"\"\"\n\n # Setup the base widget window\n super().__init__(\n WINDOW_TITLE, width=WidgetWindow.WINDOW_WIDTH, height=WidgetWindow.WINDOW_HEIGHT, visible=True, **kwargs\n )\n self.deferred_dock_in(\"Property\", ui.DockPolicy.CURRENT_WINDOW_IS_ACTIVE)\n\n # Setup the delegate that will bridge between the logic and the UI\n self._delegate = delegate\n\n # Bind the UI delegate to this window\n self._delegate.set_window_bind(self)\n\n # Auxiliar attributes for getting the transforms of the vehicle and the camera from the UI\n self._camera_transform_models = []\n self._vehicle_transform_models = []\n\n # Build the actual window UI\n self._build_window()\n\n def destroy(self):\n\n # Clear the world and the stage correctly\n self._delegate.on_clear_scene()\n\n # It will destroy all the children\n super().destroy()\n\n def _build_window(self):\n\n # Define the UI of the widget window\n with self.frame:\n \n with ui.ScrollingFrame(horizontal_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_ON, vertical_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_ON):\n\n # Vertical Stack of menus\n with ui.VStack():\n\n # Create a frame for selecting which scene to load\n self._scene_selection_frame()\n ui.Spacer(height=5)\n\n # Create a frame for selecting which vehicle to load in the simulation environment\n self._robot_selection_frame()\n ui.Spacer(height=5)\n\n # Create a frame for selecting the camera position, and what it should point torwards to\n self._viewport_camera_frame()\n ui.Spacer()\n\n def _scene_selection_frame(self):\n \"\"\"\n Method that implements a dropdown menu with the list of available simulation environemts for the vehicle\n \"\"\"\n\n # Frame for selecting the simulation environment to load\n with ui.CollapsableFrame(\"Scene Selection\"):\n with ui.VStack(height=0, spacing=10, name=\"frame_v_stack\"):\n ui.Spacer(height=WidgetWindow.GENERAL_SPACING)\n\n # Iterate over all existing pre-made worlds bundled with this extension\n with ui.HStack():\n ui.Label(\"World Assets\", width=WidgetWindow.LABEL_PADDING, height=10.0)\n\n # Combo box with the available environments to select from\n dropdown_menu = ui.ComboBox(0, height=10, name=\"environments\")\n for environment in SIMULATION_ENVIRONMENTS:\n dropdown_menu.model.append_child_item(None, ui.SimpleStringModel(environment))\n\n # Allow the delegate to know which option was selected in the dropdown menu\n self._delegate.set_scene_dropdown(dropdown_menu.model)\n\n ui.Spacer(height=0)\n\n # UI to configure the default latitude, longitude and altitude coordinates\n with ui.CollapsableFrame(\"Geographic Coordinates\", collapsed=False):\n with ui.VStack(height=0, spacing=10, name=\"frame_v_stack\"):\n with ui.HStack():\n\n # Latitude\n ui.Label(\"Latitude\", name=\"label\", width=WidgetWindow.LABEL_PADDING-50)\n latitude_field = ui.FloatField(name=\"latitude\", precision=6)\n latitude_field.model.set_value(self._delegate._latitude)\n self._delegate.set_latitude_field(latitude_field.model)\n ui.Circle(name=\"transform\", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED)\n\n # Longitude\n ui.Label(\"Longitude\", name=\"label\", width=WidgetWindow.LABEL_PADDING-50)\n longitude_field = ui.FloatField(name=\"longitude\", precision=6)\n longitude_field.model.set_value(self._delegate._longitude)\n self._delegate.set_longitude_field(longitude_field.model)\n ui.Circle(name=\"transform\", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED)\n\n # Altitude\n ui.Label(\"Altitude\", name=\"label\", width=WidgetWindow.LABEL_PADDING-50)\n altitude_field = ui.FloatField(name=\"altitude\", precision=6)\n altitude_field.model.set_value(self._delegate._altitude)\n self._delegate.set_altitude_field(altitude_field.model)\n ui.Circle(name=\"transform\", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED)\n\n with ui.HStack():\n ui.Button(\"Set\", enabled=True, clicked_fn=self._delegate.on_set_new_global_coordinates)\n ui.Button(\"Reset\", enabled=True, clicked_fn=self._delegate.on_reset_global_coordinates)\n ui.Button(\"Make Default\", enabled=True, clicked_fn=self._delegate.on_set_new_default_global_coordinates)\n\n ui.Spacer(height=0)\n\n with ui.HStack():\n # Add a thumbnail image to have a preview of the world that is about to be loaded\n with ui.ZStack(width=WidgetWindow.LABEL_PADDING, height=WidgetWindow.BUTTON_HEIGHT * 2):\n ui.Rectangle()\n ui.Image(\n WORLD_THUMBNAIL,\n fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT,\n alignment=ui.Alignment.LEFT_CENTER,\n )\n\n ui.Spacer(width=WidgetWindow.GENERAL_SPACING)\n\n with ui.VStack():\n # Button for loading a desired scene\n ui.Button(\n \"Load Scene\",\n height=WidgetWindow.BUTTON_HEIGHT,\n clicked_fn=self._delegate.on_load_scene,\n style=WidgetWindow.BUTTON_BASE_STYLE,\n )\n\n # Button to reset the stage\n ui.Button(\n \"Clear Scene\",\n height=WidgetWindow.BUTTON_HEIGHT,\n clicked_fn=self._delegate.on_clear_scene,\n style=WidgetWindow.BUTTON_BASE_STYLE,\n )\n\n def _robot_selection_frame(self):\n \"\"\"\n Method that implements a frame that allows the user to choose which robot that is about to be spawned\n \"\"\"\n\n # Auxiliary function to handle the \"switch behaviour\" of the buttons that are used to choose between a px4 or ROS2 backend\n def handle_px4_ros_switch(self, px4_button, ros2_button, button):\n\n # Handle the UI of both buttons switching of and on (To make it prettier)\n if button == \"px4\":\n px4_button.enabled = False\n ros2_button.enabled = True\n px4_button.set_style(WidgetWindow.BUTTON_SELECTED_STYLE)\n ros2_button.set_style(WidgetWindow.BUTTON_BASE_STYLE)\n else:\n px4_button.enabled = True\n ros2_button.enabled = False\n ros2_button.set_style(WidgetWindow.BUTTON_SELECTED_STYLE)\n px4_button.set_style(WidgetWindow.BUTTON_BASE_STYLE)\n\n # Handle the logic of switching between the two operating modes\n self._delegate.set_streaming_backend(button)\n\n # --------------------------\n # Function UI starts here\n # --------------------------\n\n # Frame for selecting the vehicle to load\n with ui.CollapsableFrame(title=\"Vehicle Selection\"):\n with ui.VStack(height=0, spacing=10, name=\"frame_v_stack\"):\n ui.Spacer(height=WidgetWindow.GENERAL_SPACING)\n # Iterate over all existing robots in the extension\n with ui.HStack():\n ui.Label(\"Vehicle Model\", name=\"label\", width=WidgetWindow.LABEL_PADDING)\n\n # Combo box with the available vehicles to select from\n dropdown_menu = ui.ComboBox(0, height=10, name=\"robots\")\n for robot in ROBOTS:\n dropdown_menu.model.append_child_item(None, ui.SimpleStringModel(robot))\n self._delegate.set_vehicle_dropdown(dropdown_menu.model)\n\n with ui.HStack():\n ui.Label(\"Vehicle ID\", name=\"label\", width=WidgetWindow.LABEL_PADDING)\n vehicle_id_field = ui.IntField()\n self._delegate.set_vehicle_id_field(vehicle_id_field.model)\n\n # Add a frame transform to select the position of where to place the selected robot in the world\n self._transform_frame()\n\n ui.Label(\"Streaming Backend\")\n \n with ui.HStack():\n # Add a thumbnail image to have a preview of the world that is about to be loaded\n with ui.ZStack(width=WidgetWindow.LABEL_PADDING, height=WidgetWindow.BUTTON_HEIGHT * 2):\n ui.Rectangle()\n ui.Image(\n THUMBNAIL, fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT, alignment=ui.Alignment.LEFT_CENTER\n )\n\n ui.Spacer(width=WidgetWindow.GENERAL_SPACING)\n with ui.VStack():\n # Buttons that behave like switches to choose which network interface to use to simulate the control of the vehicle\n px4_button = ui.Button(\n \"PX4\",\n height=WidgetWindow.BUTTON_HEIGHT * 2,\n style=WidgetWindow.BUTTON_SELECTED_STYLE,\n enabled=False,\n )\n ros2_button = ui.Button(\n \"ROS 2\",\n height=WidgetWindow.BUTTON_HEIGHT,\n style=WidgetWindow.BUTTON_BASE_STYLE,\n enabled=True,\n visible=False\n )\n\n # Set the auxiliary function to handle the switch between both backends\n px4_button.set_clicked_fn(lambda: handle_px4_ros_switch(self, px4_button, ros2_button, \"px4\"))\n ros2_button.set_clicked_fn(lambda: handle_px4_ros_switch(self, px4_button, ros2_button, \"ros\"))\n\n # UI to configure the PX4 settings\n with ui.CollapsableFrame(\"PX4 Configurations\", collapsed=False):\n with ui.VStack(height=0, spacing=10, name=\"frame_v_stack\"):\n with ui.HStack():\n ui.Label(\"Auto-launch PX4\", name=\"label\", width=WidgetWindow.LABEL_PADDING - 20)\n px4_checkbox = ui.CheckBox()\n px4_checkbox.model.set_value(self._delegate._autostart_px4)\n self._delegate.set_px4_autostart_checkbox(px4_checkbox.model)\n\n with ui.HStack():\n ui.Label(\"PX4 Path\", name=\"label\", width=WidgetWindow.LABEL_PADDING - 20)\n px4_path_field = ui.StringField(name=\"px4_path\", width=300)\n px4_path_field.model.set_value(self._delegate._px4_dir)\n self._delegate.set_px4_directory_field(px4_path_field.model)\n\n ui.Button(\"Reset\", enabled=True, clicked_fn=self._delegate.on_reset_px4_path)\n ui.Button(\"Make Default\", enabled=True, clicked_fn=self._delegate.on_set_new_default_px4_path)\n\n with ui.HStack():\n ui.Label(\"PX4 airframe\", name=\"label\", width=WidgetWindow.LABEL_PADDING - 20)\n px4_airframe_field = ui.StringField(name=\"px4_model\")\n px4_airframe_field.model.set_value(self._delegate._px4_airframe)\n self._delegate.set_px4_airframe_field(px4_airframe_field.model)\n\n # Button to load the drone\n ui.Button(\n \"Load Vehicle\",\n height=WidgetWindow.BUTTON_HEIGHT,\n clicked_fn=self._delegate.on_load_vehicle,\n style=WidgetWindow.BUTTON_BASE_STYLE,\n )\n\n def _viewport_camera_frame(self):\n \"\"\"\n Method that implements a frame that allows the user to choose what is the viewport camera pose easily\n \"\"\"\n\n all_axis = [\"X\", \"Y\", \"Z\"]\n colors = {\"X\": 0xFF5555AA, \"Y\": 0xFF76A371, \"Z\": 0xFFA07D4F}\n default_values = [5.0, 5.0, 5.0]\n target_default_values = [0.0, 0.0, 0.0]\n\n # Frame for setting the camera to visualize the vehicle in the simulator viewport\n with ui.CollapsableFrame(\"Viewport Camera\"):\n with ui.VStack(spacing=8):\n ui.Spacer(height=0)\n\n # Iterate over the position and rotation menus\n with ui.HStack():\n with ui.HStack():\n ui.Label(\"Position\", name=\"transform\", width=50, height=20)\n ui.Spacer()\n # Fields X, Y and Z\n for axis, default_value in zip(all_axis, default_values):\n with ui.HStack():\n with ui.ZStack(width=15):\n ui.Rectangle(\n width=15,\n height=20,\n style={\n \"background_color\": colors[axis],\n \"border_radius\": 3,\n \"corner_flag\": ui.CornerFlag.LEFT,\n },\n )\n ui.Label(axis, height=20, name=\"transform_label\", alignment=ui.Alignment.CENTER)\n float_drag = ui.FloatDrag(name=\"transform\", min=-1000000, max=1000000, step=0.01)\n float_drag.model.set_value(default_value)\n # Save the model of each FloatDrag such that we can access its values later on\n self._camera_transform_models.append(float_drag.model)\n ui.Circle(\n name=\"transform\", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED\n )\n\n # Iterate over the position and rotation menus\n with ui.HStack():\n with ui.HStack():\n ui.Label(\"Target\", name=\"transform\", width=50, height=20)\n ui.Spacer()\n # Fields X, Y and Z\n for axis, default_value in zip(all_axis, target_default_values):\n with ui.HStack():\n with ui.ZStack(width=15):\n ui.Rectangle(\n width=15,\n height=20,\n style={\n \"background_color\": colors[axis],\n \"border_radius\": 3,\n \"corner_flag\": ui.CornerFlag.LEFT,\n },\n )\n ui.Label(axis, height=20, name=\"transform_label\", alignment=ui.Alignment.CENTER)\n float_drag = ui.FloatDrag(name=\"transform\", min=-1000000, max=1000000, step=0.01)\n float_drag.model.set_value(default_value)\n # Save the model of each FloatDrag such that we can access its values later on\n self._camera_transform_models.append(float_drag.model)\n ui.Circle(\n name=\"transform\", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED\n )\n\n # Button to set the camera view\n ui.Button(\n \"Set Camera Pose\",\n height=WidgetWindow.BUTTON_HEIGHT,\n clicked_fn=self._delegate.on_set_viewport_camera,\n style=WidgetWindow.BUTTON_BASE_STYLE,\n )\n ui.Spacer()\n\n def _transform_frame(self):\n \"\"\"\n Method that implements a transform frame to translate and rotate an object that is about to be spawned\n \"\"\"\n\n components = [\"Position\", \"Rotation\"]\n all_axis = [\"X\", \"Y\", \"Z\"]\n colors = {\"X\": 0xFF5555AA, \"Y\": 0xFF76A371, \"Z\": 0xFFA07D4F}\n default_values = [0.0, 0.0, 0.1]\n\n with ui.CollapsableFrame(\"Position and Orientation\"):\n with ui.VStack(spacing=8):\n\n ui.Spacer(height=0)\n\n # Iterate over the position and rotation menus\n for component in components:\n with ui.HStack():\n with ui.HStack():\n ui.Label(component, name=\"transform\", width=50)\n ui.Spacer()\n # Fields X, Y and Z\n for axis, default_value in zip(all_axis, default_values):\n with ui.HStack():\n with ui.ZStack(width=15):\n ui.Rectangle(\n width=15,\n height=20,\n style={\n \"background_color\": colors[axis],\n \"border_radius\": 3,\n \"corner_flag\": ui.CornerFlag.LEFT,\n },\n )\n ui.Label(axis, name=\"transform_label\", alignment=ui.Alignment.CENTER)\n if component == \"Position\":\n float_drag = ui.FloatDrag(name=\"transform\", min=-1000000, max=1000000, step=0.01)\n float_drag.model.set_value(default_value)\n else:\n float_drag = ui.FloatDrag(name=\"transform\", min=-180.0, max=180.0, step=0.01)\n # Save the model of each FloatDrag such that we can access its values later on\n self._vehicle_transform_models.append(float_drag.model)\n ui.Circle(name=\"transform\", width=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED)\n ui.Spacer(height=0)\n\n # ------------------------------------------------------------------------------------------------\n # TODO - optimize the reading of values from the transform widget. This could be one function only\n # ------------------------------------------------------------------------------------------------\n\n def get_selected_vehicle_attitude(self):\n\n # Extract the vehicle desired position and orientation for spawning\n if len(self._vehicle_transform_models) == 6:\n vehicle_pos = np.array([self._vehicle_transform_models[i].get_value_as_float() for i in range(3)])\n vehicel_orientation = np.array(\n [self._vehicle_transform_models[i].get_value_as_float() for i in range(3, 6)]\n )\n return vehicle_pos, vehicel_orientation\n\n return None, None\n\n def get_selected_camera_pos(self):\n \"\"\"\n Method that returns the currently selected camera position in the camera transform widget\n \"\"\"\n\n # Extract the camera desired position and the target it is pointing to\n if len(self._camera_transform_models) == 6:\n camera_pos = np.array([self._camera_transform_models[i].get_value_as_float() for i in range(3)])\n camera_target = np.array([self._camera_transform_models[i].get_value_as_float() for i in range(3, 6)])\n return camera_pos, camera_target\n\n return None, None\n"},"size":{"kind":"number","value":22406,"string":"22,406"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":48.030634468204305,"string":"48.030634"},"max_line_length":{"kind":"number","value":169,"string":"169"},"alphanum_fraction":{"kind":"number","value":0.5124073908545743,"string":"0.512407"}}},{"rowIdx":57,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/ui/ui_delegate.py"},"content":{"kind":"string","value":"\"\"\"\n| File: ui_delegate.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of the UiDelegate which is an abstraction layer betweeen the extension UI and code logic features\n\"\"\"\n\n# External packages\nimport os\nimport asyncio\nfrom scipy.spatial.transform import Rotation\n\n# Omniverse extensions\nimport carb\nimport omni.ui as ui\n\n# Extension Configurations\nfrom pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\n\n# Vehicle Manager to spawn Vehicles\nfrom pegasus.simulator.logic.backends import MavlinkBackend, MavlinkBackendConfig #, ROS2Backend\nfrom pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig\nfrom pegasus.simulator.logic.vehicle_manager import VehicleManager\n\n\nclass UIDelegate:\n \"\"\"\n Object that will interface between the logic/dynamic simulation part of the extension and the Widget UI\n \"\"\"\n\n def __init__(self):\n\n # The window that will be bound to this delegate\n self._window = None\n\n # Get an instance of the pegasus simulator\n self._pegasus_sim: PegasusInterface = PegasusInterface()\n\n # Attribute that holds the currently selected scene from the dropdown menu\n self._scene_dropdown: ui.AbstractItemModel = None\n self._scene_names = list(SIMULATION_ENVIRONMENTS.keys())\n\n # Selected latitude, longitude and altitude\n self._latitude_field: ui.AbstractValueModel = None\n self._latitude = PegasusInterface().latitude\n self._longitude_field: ui.AbstractValueModel = None\n self._longitude = PegasusInterface().longitude\n self._altitude_field: ui.AbstractValueModel = None\n self._altitude = PegasusInterface().altitude\n\n # Attribute that hold the currently selected vehicle from the dropdown menu\n self._vehicle_dropdown: ui.AbstractItemModel = None\n self._vehicles_names = list(ROBOTS.keys())\n\n # Get an instance of the vehicle manager\n self._vehicle_manager = VehicleManager()\n\n # Selected option for broadcasting the simulated vehicle (PX4+ROS2 or just ROS2)\n # By default we assume PX4\n self._streaming_backend: str = \"px4\"\n\n # Selected value for the the id of the vehicle\n self._vehicle_id_field: ui.AbstractValueModel = None\n self._vehicle_id: int = 0\n\n # Attribute that will save the model for the px4-autostart checkbox\n self._px4_autostart_checkbox: ui.AbstractValueModel = None\n self._autostart_px4: bool = True\n\n # Atributes to store the path for the Px4 directory\n self._px4_directory_field: ui.AbstractValueModel = None\n self._px4_dir: str = PegasusInterface().px4_path\n\n # Atributes to store the PX4 airframe\n self._px4_airframe_field: ui.AbstractValueModel = None\n self._px4_airframe: str = self._pegasus_sim.px4_default_airframe\n\n def set_window_bind(self, window):\n self._window = window\n\n def set_scene_dropdown(self, scene_dropdown_model: ui.AbstractItemModel):\n self._scene_dropdown = scene_dropdown_model\n \n def set_latitude_field(self, latitude_model: ui.AbstractValueModel):\n self._latitude_field = latitude_model\n \n def set_longitude_field(self, longitude_model: ui.AbstractValueModel):\n self._longitude_field = longitude_model\n\n def set_altitude_field(self, altitude_model: ui.AbstractValueModel):\n self._altitude_field = altitude_model\n\n def set_vehicle_dropdown(self, vehicle_dropdown_model: ui.AbstractItemModel):\n self._vehicle_dropdown = vehicle_dropdown_model\n\n def set_vehicle_id_field(self, vehicle_id_field: ui.AbstractValueModel):\n self._vehicle_id_field = vehicle_id_field\n\n def set_streaming_backend(self, backend: str = \"px4\"):\n carb.log_info(\"Chosen option: \" + backend)\n self._streaming_backend = backend\n\n def set_px4_autostart_checkbox(self, checkbox_model:ui.AbstractValueModel):\n self._px4_autostart_checkbox = checkbox_model\n\n def set_px4_directory_field(self, directory_field_model: ui.AbstractValueModel):\n self._px4_directory_field = directory_field_model\n\n def set_px4_airframe_field(self, airframe_field_model: ui.AbstractValueModel):\n self._px4_airframe_field = airframe_field_model\n\n \"\"\"\n ---------------------------------------------------------------------\n Callbacks to handle user interaction with the extension widget window\n ---------------------------------------------------------------------\n \"\"\"\n\n def on_load_scene(self):\n \"\"\"\n Method that should be invoked when the button to load the selected world is pressed\n \"\"\"\n\n # Check if a scene is selected in the drop-down menu\n if self._scene_dropdown is not None:\n\n # Get the id of the selected environment from the list\n environemnt_index = self._scene_dropdown.get_item_value_model().as_int\n\n # Get the name of the selected world\n selected_world = self._scene_names[environemnt_index]\n\n # Try to spawn the selected world\n asyncio.ensure_future(self._pegasus_sim.load_environment_async(SIMULATION_ENVIRONMENTS[selected_world], force_clear=True))\n\n def on_set_new_global_coordinates(self):\n \"\"\"\n Method that gets invoked to set new global coordinates for this simulation\n \"\"\"\n self._pegasus_sim.set_global_coordinates(\n self._latitude_field.get_value_as_float(),\n self._longitude_field.get_value_as_float(),\n self._altitude_field.get_value_as_float())\n \n def on_reset_global_coordinates(self):\n \"\"\"\n Method that gets invoked to set the global coordinates to the defaults saved in the extension configuration file\n \"\"\"\n self._pegasus_sim.set_default_global_coordinates()\n\n self._latitude_field.set_value(self._pegasus_sim.latitude)\n self._longitude_field.set_value(self._pegasus_sim.longitude)\n self._altitude_field.set_value(self._pegasus_sim.altitude)\n\n def on_set_new_default_global_coordinates(self):\n \"\"\"\n Method that gets invoked to set new defualt global coordinates for this simulation. This will attempt\n to save the current coordinates as new defaults for the extension itself\n \"\"\"\n self._pegasus_sim.set_new_default_global_coordinates(\n self._latitude_field.get_value_as_float(),\n self._longitude_field.get_value_as_float(),\n self._altitude_field.get_value_as_float()\n )\n\n def on_clear_scene(self):\n \"\"\"\n Method that should be invoked when the clear world button is pressed\n \"\"\"\n self._pegasus_sim.clear_scene()\n\n def on_load_vehicle(self):\n \"\"\"\n Method that should be invoked when the button to load the selected vehicle is pressed\n \"\"\"\n\n async def async_load_vehicle():\n\n # Check if we already have a physics environment activated. If not, then activate it\n # and only after spawn the vehicle. This is to avoid trying to spawn a vehicle without a physics\n # environment setup. This way we can even spawn a vehicle in an empty world and it won't care\n if hasattr(self._pegasus_sim.world, \"_physics_context\") == False:\n await self._pegasus_sim.world.initialize_simulation_context_async()\n\n # Check if a vehicle is selected in the drop-down menu\n if self._vehicle_dropdown is not None and self._window is not None:\n\n # Get the id of the selected vehicle from the list\n vehicle_index = self._vehicle_dropdown.get_item_value_model().as_int\n\n # Get the name of the selected vehicle\n selected_robot = self._vehicles_names[vehicle_index]\n\n # Get the id of the selected vehicle\n self._vehicle_id = self._vehicle_id_field.get_value_as_int()\n\n # Get the desired position and orientation of the vehicle from the UI transform\n pos, euler_angles = self._window.get_selected_vehicle_attitude()\n\n # Read if we should auto-start px4 from the checkbox\n px4_autostart = self._px4_autostart_checkbox.get_value_as_bool()\n\n # Read the PX4 path from the field\n px4_path = os.path.expanduser(self._px4_directory_field.get_value_as_string())\n\n # Read the PX4 airframe from the field\n px4_airframe = self._px4_airframe_field.get_value_as_string()\n\n # Create the multirotor configuration\n mavlink_config = MavlinkBackendConfig({\n \"vehicle_id\": self._vehicle_id,\n \"px4_autolaunch\": px4_autostart,\n \"px4_dir\": px4_path,\n \"px4_vehicle_model\": px4_airframe\n })\n config_multirotor = MultirotorConfig()\n config_multirotor.backends = [MavlinkBackend(mavlink_config)]\n\n #ros2 = ROS2Backend(self._vehicle_id)\n\n # Try to spawn the selected robot in the world to the specified namespace\n Multirotor(\n \"/World/quadrotor\",\n ROBOTS[selected_robot],\n self._vehicle_id,\n pos,\n Rotation.from_euler(\"XYZ\", euler_angles, degrees=True).as_quat(),\n config=config_multirotor,\n )\n\n # Log that a vehicle of the type multirotor was spawned in the world via the extension UI\n carb.log_info(\"Spawned the robot: \" + selected_robot + \" using the Pegasus Simulator UI\")\n else:\n # Log that it was not possible to spawn the vehicle in the world using the Pegasus Simulator UI\n carb.log_error(\"Could not spawn the robot using the Pegasus Simulator UI\")\n\n # Run the actual vehicle spawn async so that the UI does not freeze\n asyncio.ensure_future(async_load_vehicle()) \n\n def on_set_viewport_camera(self):\n \"\"\"\n Method that should be invoked when the button to set the viewport camera pose is pressed\n \"\"\"\n carb.log_warn(\"The viewport camera pose has been adjusted\")\n\n if self._window:\n\n # Get the current camera position value\n camera_position, camera_target = self._window.get_selected_camera_pos()\n\n if camera_position is not None and camera_target is not None:\n\n # Set the camera view to a fixed value\n self._pegasus_sim.set_viewport_camera(eye=camera_position, target=camera_target)\n \n def on_set_new_default_px4_path(self):\n \"\"\"\n Method that will try to update the new PX4 autopilot path with whatever is passed on the string field\n \"\"\"\n carb.log_warn(\"A new default PX4 Path will be set for the extension.\")\n\n # Read the current path from the field\n path = self._px4_directory_field.get_value_as_string()\n\n # Set the path using the pegasus interface\n self._pegasus_sim.set_px4_path(path)\n\n def on_reset_px4_path(self):\n \"\"\"\n Method that will reset the string field to the default PX4 path\n \"\"\"\n carb.log_warn(\"Reseting the path to the default one\")\n self._px4_directory_field.set_value(self._pegasus_sim.px4_path)\n"},"size":{"kind":"number","value":11596,"string":"11,596"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":41.32481736742768,"string":"41.324817"},"max_line_length":{"kind":"number","value":134,"string":"134"},"alphanum_fraction":{"kind":"number","value":0.6434115211587261,"string":"0.643412"}}},{"rowIdx":58,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/ui/__init__.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\nfrom .ui_delegate import UIDelegate\nfrom .ui_window import WidgetWindow\n"},"size":{"kind":"number","value":175,"string":"175"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":24.142853693878042,"string":"24.142854"},"max_line_length":{"kind":"number","value":39,"string":"39"},"alphanum_fraction":{"kind":"number","value":0.7771428527020409,"string":"0.777143"}}},{"rowIdx":59,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicle_manager.py"},"content":{"kind":"string","value":"\"\"\"\n| File: vehicle_manager.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of the VehicleManager class - a singleton used to manage the vehiles that are spawned in the simulation world\n\"\"\"\n\n__all__ = [\"VehicleManager\"]\n\nimport carb\nfrom threading import Lock\n\n\nclass VehicleManager:\n \"\"\"The VehicleManager class is implemented following a singleton pattern. This means that once a vehicle is spawned\n on the world or an instance of the VehicleManager is created, no either will be running at the same time.\n\n This class keeps track of all the vehicles that are spawned in the simulation world, either trough the extension UI\n or via Python script. Every time a new vehicle object is created, the 'add_vehicle' method is invoked. Additionally, \n a vehicle is removed, i.e. 'remove_vehicle' gets invoked, every time the '__del__' function of the \"Vehicle\" object\n gets invoked.\n \"\"\"\n\n # The object instance of the Vehicle Manager\n _instance = None\n _is_initialized = False\n \n # A dictionary of vehicles that are spawned in the simulator\n _vehicles = {}\n\n # Lock for safe multi-threading\n _lock: Lock = Lock()\n\n def __init__(self):\n \"\"\"\n Constructor for the vehicle manager class.\n \"\"\"\n pass\n\n \"\"\"\n Properties\n \"\"\"\n\n @property\n def vehicles(self):\n \"\"\"\n Returns:\n (list) List of vehicles that were spawned.\n \"\"\"\n return VehicleManager._vehicles\n\n \"\"\"\n Operations\n \"\"\"\n\n @staticmethod\n def get_vehicle_manager():\n \"\"\"\n Method that returns the current vehicle manager.\n \"\"\"\n return VehicleManager()\n\n def add_vehicle(self, stage_prefix: str, vehicle):\n \"\"\"\n Method that adds the vehicles to the vehicle manager.\n\n Args:\n stage_prefix (str): A string with the name that the vehicle is spawned in the simulator\n vehicle (Vehicle): The vehicle object being added to the vehicle manager.\n \"\"\"\n VehicleManager._vehicles[stage_prefix] = vehicle\n\n def get_vehicle(self, stage_prefix: str):\n \"\"\"Method that returns the vehicle object given its stage prefix. Returns None if there is no vehicle\n associated with that stage prefix\n\n Args:\n stage_prefix (str): A string with the name that the vehicle is spawned in the simulator\n\n Returns:\n Vehicle: The vehicle object associated with the stage_prefix\n \"\"\"\n return VehicleManager._vehicles.get(stage_prefix, None)\n\n def remove_vehicle(self, stage_prefix: str):\n \"\"\"\n Method that deletes a vehicle from the vehicle manager.\n\n Args:\n stage_prefix (str): A string with the name that the vehicle is spawned in the simulator.\n \"\"\"\n try:\n VehicleManager._vehicles.pop(stage_prefix)\n except:\n pass\n\n def remove_all_vehicles(self):\n \"\"\"\n Method that will delete all the vehicles that were spawned from the vehicle manager.\n \"\"\"\n\n VehicleManager._vehicles.clear()\n\n def __new__(cls):\n \"\"\"Method that allocated memory for a new vehicle_manager. Since the VehicleManager follows a singleton pattern,\n only one instance of VehicleManger object can be in memory at any time.\n\n Returns:\n VehicleManger: the single instance of the VehicleManager class.\n \"\"\"\n\n # Use a lock in here to make sure we do not have a race condition\n # when using multi-threading and creating the first instance of the VehicleManager\n with cls._lock:\n if cls._instance is None:\n cls._instance = object.__new__(cls)\n else:\n carb.log_info(\"Vehicle Manager is defined already, returning the previously defined one\")\n\n return VehicleManager._instance\n\n def __del__(self):\n \"\"\"Destructor for the object\"\"\"\n VehicleManager._instance = None\n return\n"},"size":{"kind":"number","value":4124,"string":"4,124"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":31.738094986205596,"string":"31.738095"},"max_line_length":{"kind":"number","value":135,"string":"135"},"alphanum_fraction":{"kind":"number","value":0.6408826380599217,"string":"0.640883"}}},{"rowIdx":60,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/state.py"},"content":{"kind":"string","value":"\"\"\"\n| File: state.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Describes the state of a vehicle (or rigidbody).\n\"\"\"\n__all__ = [\"State\"]\n\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\nfrom pegasus.simulator.logic.rotations import rot_ENU_to_NED, rot_FLU_to_FRD\n\n\nclass State:\n \"\"\"\n Stores the state of a given vehicle.\n \n Note:\n - position - A numpy array with the [x,y,z] of the vehicle expressed in the inertial frame according to an ENU convention.\n - orientation - A numpy array with the quaternion [qx, qy, qz, qw] that encodes the attitude of the vehicle's FLU body frame, relative to an ENU inertial frame, expressed in the ENU inertial frame.\n - linear_velocity - A numpy array with [vx,vy,vz] that defines the velocity of the vehicle expressed in the inertial frame according to an ENU convention.\n - linear_body_velocity - A numpy array with [u,v,w] that defines the velocity of the vehicle expressed in the FLU body frame.\n - angular_velocity - A numpy array with [p,q,r] with the angular velocity of the vehicle's FLU body frame, relative to an ENU inertial frame, expressed in the FLU body frame.\n - linear acceleration - An array with [x_ddot, y_ddot, z_ddot] with the acceleration of the vehicle expressed in the inertial frame according to an ENU convention.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Initialize the State object\n \"\"\"\n\n # The position [x,y,z] of the vehicle's body frame relative to the inertial frame, expressed in the inertial frame\n self.position = np.array([0.0, 0.0, 0.0])\n\n # The attitude (orientation) of the vehicle's body frame relative to the inertial frame of reference,\n # expressed in the inertial frame. This quaternion should follow the convention [qx, qy, qz, qw], such that \"no rotation\"\n # equates to the quaternion=[0, 0, 0, 1]\n self.attitude = np.array([0.0, 0.0, 0.0, 1.0])\n\n # The linear velocity [u,v,w] of the vehicle's body frame expressed in the body frame of reference\n self.linear_body_velocity = np.array([0.0, 0.0, 0.0])\n\n # The linear velocity [x_dot, y_dot, z_dot] of the vehicle's body frame expressed in the inertial frame of reference\n self.linear_velocity = np.array([0.0, 0.0, 0.0])\n\n # The angular velocity [wx, wy, wz] of the vehicle's body frame relative to the inertial frame, expressed in the body frame\n self.angular_velocity = np.array([0.0, 0.0, 0.0])\n\n # The linear acceleration [ax, ay, az] of the vehicle's body frame relative to the inertial frame, expressed in the inertial frame\n self.linear_acceleration = np.array([0.0, 0.0, 0.0])\n\n def get_position_ned(self):\n \"\"\"\n Method that, assuming that a state is encoded in ENU standard (the Isaac Sim standard), converts the position\n to the NED convention used by PX4 and other onboard flight controllers\n\n Returns:\n np.ndarray: A numpy array with the [x,y,z] of the vehicle expressed in the inertial frame according to an NED convention.\n \"\"\"\n return rot_ENU_to_NED.apply(self.position)\n\n def get_attitude_ned_frd(self):\n \"\"\"\n Method that, assuming that a state is encoded in ENU-FLU standard (the Isaac Sim standard), converts the\n attitude of the vehicle it to the NED-FRD convention used by PX4 and other onboard flight controllers\n\n Returns:\n np.ndarray: A numpy array with the quaternion [qx, qy, qz, qw] that encodes the attitude of the vehicle's FRD body frame, relative to an NED inertial frame, expressed in the NED inertial frame.\n \"\"\"\n attitude_frd_ned = rot_ENU_to_NED * Rotation.from_quat(self.attitude) * rot_FLU_to_FRD\n return attitude_frd_ned.as_quat()\n\n def get_linear_body_velocity_ned_frd(self):\n \"\"\"\n Method that, assuming that a state is encoded in ENU-FLU standard (the Isaac Sim standard), converts the\n linear body velocity of the vehicle it to the NED-FRD convention used by PX4 and other onboard flight controllers\n\n Returns:\n np.ndarray: A numpy array with [u,v,w] that defines the velocity of the vehicle expressed in the FRD body frame.\n \"\"\"\n\n # Get the linear acceleration in FLU convention\n linear_acc_body_flu = Rotation.from_quat(self.attitude).inv().apply(self.linear_acceleration)\n\n # Convert the linear acceleration in the body frame expressed in FLU convention to the FRD convention\n return rot_FLU_to_FRD.apply(linear_acc_body_flu)\n\n def get_linear_velocity_ned(self):\n \"\"\"\n Method that, assuming that a state is enconded in ENU-FLU standard (the Isaac Sim standard), converts the\n linear velocity expressed in the inertial frame to the NED convention used by PX4 and other onboard flight\n controllers\n\n Returns:\n np.ndarray: A numpy array with [vx,vy,vz] that defines the velocity of the vehicle expressed in the inertial frame according to a NED convention.\n \"\"\"\n return rot_ENU_to_NED.apply(self.linear_velocity)\n\n def get_angular_velocity_frd(self):\n \"\"\"\n Method that, assuming that a state is enconded in ENU-FLU standard (the Isaac Sim standard), converts the\n angular velocity expressed in the body frame to the NED-FRD convention used by PX4 and other onboard flight\n controllers\n\n Returns:\n np.ndarray: A numpy array with [p,q,r] with the angular velocity of the vehicle's FRD body frame, relative to an NED inertial frame, expressed in the FRD body frame.\n \"\"\"\n return rot_FLU_to_FRD.apply(self.angular_velocity)\n\n def get_linear_acceleration_ned(self):\n \"\"\"\n Method that, assuming that a state is enconded in ENU-FLU standard (the Isaac Sim standard), converts the\n linear acceleration expressed in the inertial frame to the NED convention used by PX4 and other onboard flight\n controllers\n\n Returns:\n np.ndarray: An array with [x_ddot, y_ddot, z_ddot] with the acceleration of the vehicle expressed in the inertial frame according to an NED convention.\n \"\"\"\n return rot_ENU_to_NED.apply(self.linear_acceleration)\n"},"size":{"kind":"number","value":6384,"string":"6,384"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":52.20833289826389,"string":"52.208333"},"max_line_length":{"kind":"number","value":205,"string":"205"},"alphanum_fraction":{"kind":"number","value":0.6842105262086136,"string":"0.684211"}}},{"rowIdx":61,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/__init__.py"},"content":{"kind":"string","value":"\"\"\"\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n\nfrom .interface.pegasus_interface import PegasusInterface"},"size":{"kind":"number","value":212,"string":"212"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":34.49999425000096,"string":"34.499994"},"max_line_length":{"kind":"number","value":82,"string":"82"},"alphanum_fraction":{"kind":"number","value":0.7688679209015664,"string":"0.768868"}}},{"rowIdx":62,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/rotations.py"},"content":{"kind":"string","value":"\"\"\"\n| File: rotations.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Implements utilitary rotations between ENU and NED inertial frame conventions and FLU and FRD body frame conventions.\n\"\"\"\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\n# Quaternion for rotation between ENU and NED INERTIAL frames\n# NED to ENU: +PI/2 rotation about Z (Down) followed by a +PI rotation around X (old North/new East)\n# ENU to NED: +PI/2 rotation about Z (Up) followed by a +PI rotation about X (old East/new North)\n# This rotation is symmetric, so q_ENU_to_NED == q_NED_to_ENU.\n# Note: this quaternion follows the convention [qx, qy, qz, qw]\nq_ENU_to_NED = np.array([0.70711, 0.70711, 0.0, 0.0])\n\n# A scipy rotation from the ENU inertial frame to the NED inertial frame of reference\nrot_ENU_to_NED = Rotation.from_quat(q_ENU_to_NED)\n\n# Quaternion for rotation between body FLU and body FRD frames\n# +PI rotation around X (Forward) axis rotates from Forward, Right, Down (aircraft)\n# to Forward, Left, Up (base_link) frames and vice-versa.\n# This rotation is symmetric, so q_FLU_to_FRD == q_FRD_to_FLU.\n# Note: this quaternion follows the convention [qx, qy, qz, qw]\nq_FLU_to_FRD = np.array([1.0, 0.0, 0.0, 0.0])\n\n# A scipe rotation from the FLU body frame to the FRD body frame\nrot_FLU_to_FRD = Rotation.from_quat(q_FLU_to_FRD)\n"},"size":{"kind":"number","value":1447,"string":"1,447"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":48.93103279548163,"string":"48.931033"},"max_line_length":{"kind":"number","value":132,"string":"132"},"alphanum_fraction":{"kind":"number","value":0.7353144431684073,"string":"0.735314"}}},{"rowIdx":63,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/__init__.py"},"content":{"kind":"string","value":"\"\"\"\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n\nfrom .thrust_curve import ThrustCurve\nfrom .quadratic_thrust_curve import QuadraticThrustCurve"},"size":{"kind":"number","value":249,"string":"249"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":34.71428075510275,"string":"34.714281"},"max_line_length":{"kind":"number","value":82,"string":"82"},"alphanum_fraction":{"kind":"number","value":0.779116462734472,"string":"0.779116"}}},{"rowIdx":64,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/quadratic_thrust_curve.py"},"content":{"kind":"string","value":"\"\"\"\n| File: quadratic_thrust_curve.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Descriptio: File that implements a quadratic thrust curve for rotors\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\nimport numpy as np\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.thrusters.thrust_curve import ThrustCurve\n\nclass QuadraticThrustCurve(ThrustCurve):\n \"\"\"Class that implements the dynamics of rotors that can be described by a quadratic thrust curve\n \"\"\"\n def __init__(self, config={}):\n \"\"\"_summary_\n\n Args:\n config (dict): A Dictionary that contains all the parameters for configuring the QuadraticThrustCurve - it can be empty or only have some of the parameters used by the QuadraticThrustCurve.\n \n Examples:\n The dictionary default parameters are\n\n >>> {\"num_rotors\": 4,\n >>> \"rotor_constant\": [5.84e-6, 5.84e-6, 5.84e-6, 5.84e-6],\n >>> \"rolling_moment_coefficient\": [1e-6, 1e-6, 1e-6, 1e-6],\n >>> \"rot_dir\": [-1, -1, 1, 1],\n >>> \"min_rotor_velocity\": [0, 0, 0, 0], # rad/s\n >>> \"max_rotor_velocity\": [1100, 1100, 1100, 1100], # rad/s\n >>> }\n \"\"\"\n\n # Get the total number of rotors to simulate\n self._num_rotors = config.get(\"num_rotors\", 4)\n\n # The rotor constant used for computing the total thrust produced by the rotor: T = rotor_constant * omega^2\n self._rotor_constant = config.get(\"rotor_constant\", [8.54858e-6, 8.54858e-6, 8.54858e-6, 8.54858e-6])\n assert len(self._rotor_constant) == self._num_rotors\n\n # The rotor constant used for computing the total torque generated about the vehicle Z-axis\n self._rolling_moment_coefficient = config.get(\"rolling_moment_coefficient\", [1e-6, 1e-6, 1e-6, 1e-6])\n assert len(self._rolling_moment_coefficient) == self._num_rotors\n\n # Save the rotor direction of rotation\n self._rot_dir = config.get(\"rot_dir\", [-1, -1, 1, 1])\n assert len(self._rot_dir) == self._num_rotors\n\n # Values for the minimum and maximum rotor velocity in rad/s\n self.min_rotor_velocity = config.get(\"min_rotor_velocity\", [0, 0, 0, 0])\n assert len(self.min_rotor_velocity) == self._num_rotors\n\n self.max_rotor_velocity = config.get(\"max_rotor_velocity\", [1100, 1100, 1100, 1100])\n assert len(self.max_rotor_velocity) == self._num_rotors\n\n # The actual speed references to apply to the vehicle rotor joints\n self._input_reference = [0.0 for i in range(self._num_rotors)]\n\n # The actual velocity that each rotor is spinning at\n self._velocity = [0.0 for i in range(self._num_rotors)]\n\n # The actual force that each rotor is generating\n self._force = [0.0 for i in range(self._num_rotors)]\n\n # The actual rolling moment that is generated on the body frame of the vehicle\n self._rolling_moment = 0.0\n\n def set_input_reference(self, input_reference):\n \"\"\"\n Receives as input a list of target angular velocities of each rotor in rad/s\n \"\"\"\n\n # The target angular velocity of the rotor\n self._input_reference = input_reference\n\n def update(self, state: State, dt: float):\n \"\"\"\n Note: the state and dt variables are not used in this implementation, but left\n to add support to other rotor models where the total thrust is dependent on\n states such as vehicle linear velocity\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n\n rolling_moment = 0.0\n\n # Compute the actual force to apply to the rotors and the rolling moment contribution\n for i in range(self._num_rotors):\n\n # Set the actual velocity that each rotor is spinning at (instanenous model - no delay introduced)\n # Only apply clipping of the input reference\n self._velocity[i] = np.maximum(\n self.min_rotor_velocity[i], np.minimum(self._input_reference[i], self.max_rotor_velocity[i])\n )\n\n # Set the force using a quadratic thrust curve\n self._force[i] = self._rotor_constant[i] * np.power(self._velocity[i], 2)\n\n # Compute the rolling moment coefficient\n rolling_moment += self._rolling_moment_coefficient[i] * np.power(self._velocity[i], 2.0) * self._rot_dir[i]\n\n # Update the rolling moment variable\n self._rolling_moment = rolling_moment\n\n # Return the forces and velocities on each rotor and total torque applied on the body frame\n return self._force, self._velocity, self._rolling_moment\n\n @property\n def force(self):\n \"\"\"The force to apply to each rotor of the vehicle at any given time instant\n\n Returns:\n list: A list of forces (in Newton N) to apply to each rotor of the vehicle (on its Z-axis) at any given time instant\n \"\"\"\n return self._force\n\n @property\n def velocity(self):\n \"\"\"The velocity at which each rotor of the vehicle should be rotating at any given time instant\n\n Returns:\n list: A list of angular velocities (in rad/s) of each rotor (about its Z-axis) at any given time instant\n \"\"\"\n return self._velocity\n\n @property\n def rolling_moment(self):\n \"\"\"The total rolling moment being generated on the body frame of the vehicle by the rotating propellers\n\n Returns:\n float: The total rolling moment to apply to the vehicle body frame (Torque about the Z-axis) in Nm\n \"\"\"\n return self._rolling_moment\n\n @property\n def rot_dir(self):\n \"\"\"The direction of rotation of each rotor of the vehicle\n\n Returns:\n list(int): A list with the rotation direction of each rotor (-1 is counter-clockwise and 1 for clockwise)\n \"\"\"\n return self._rot_dir\n"},"size":{"kind":"number","value":6097,"string":"6,097"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":41.64335635214436,"string":"41.643356"},"max_line_length":{"kind":"number","value":201,"string":"201"},"alphanum_fraction":{"kind":"number","value":0.6326061996666219,"string":"0.632606"}}},{"rowIdx":65,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/thrust_curve.py"},"content":{"kind":"string","value":"\"\"\"\n| File: thrust_curve.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Descriptio: File that implements the base interface for defining thrust curves for vehicles\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\nfrom pegasus.simulator.logic.state import State\n\n\nclass ThrustCurve:\n \"\"\"Class that implements the dynamics of rotors that can be described by a quadratic thrust curve\n \"\"\"\n def __init__(self):\n pass\n\n def set_input_reference(self, input_reference):\n \"\"\"\n Receives as input a list of target angular velocities of each rotor in rad/s\n \"\"\"\n pass\n\n def update(self, state: State, dt: float):\n \"\"\"\n Note: the state and dt variables are not used in this implementation, but left\n to add support to other rotor models where the total thrust is dependent on\n states such as vehicle linear velocity\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n pass\n\n @property\n def force(self):\n \"\"\"The force to apply to each rotor of the vehicle at any given time instant\n\n Returns:\n list: A list of forces (in Newton N) to apply to each rotor of the vehicle (on its Z-axis) at any given time instant\n \"\"\"\n pass\n\n @property\n def velocity(self):\n \"\"\"The velocity at which each rotor of the vehicle should be rotating at any given time instant\n\n Returns:\n list: A list of angular velocities (in rad/s) of each rotor (about its Z-axis) at any given time instant\n \"\"\"\n pass\n\n @property\n def rolling_moment(self):\n \"\"\"The total rolling moment being generated on the body frame of the vehicle by the rotating propellers\n\n Returns:\n float: The total rolling moment to apply to the vehicle body frame (Torque about the Z-axis) in Nm\n \"\"\"\n pass\n\n @property\n def rot_dir(self):\n \"\"\"The direction of rotation of each rotor of the vehicle\n\n Returns:\n list(int): A list with the rotation direction of each rotor (-1 is counter-clockwise and 1 for clockwise)\n \"\"\"\n pass"},"size":{"kind":"number","value":2307,"string":"2,307"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":32.94117598615918,"string":"32.941176"},"max_line_length":{"kind":"number","value":128,"string":"128"},"alphanum_fraction":{"kind":"number","value":0.6428261809090481,"string":"0.642826"}}},{"rowIdx":66,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/ros2_camera.py"},"content":{"kind":"string","value":"\"\"\"\n| File: ros2_camera.py\n| License: BSD-3-Clause. Copyright (c) 2023, Micah Nye. All rights reserved.\n\"\"\"\n__all__ = [\"ROS2Camera\"]\n\nimport carb\n\nfrom omni.isaac.core.utils import stage\nimport omni.graph.core as og\nfrom omni.isaac.core.utils.prims import is_prim_path_valid\nfrom omni.isaac.core.utils.prims import set_targets\n\nfrom pegasus.simulator.logic.graphs import Graph\nfrom pegasus.simulator.logic.vehicles import Vehicle\nimport numpy as np\n\nclass ROS2Camera(Graph):\n \"\"\"The class that implements the ROS2 Camera graph. This class inherits the base class Graph.\n \"\"\"\n def __init__(self, camera_prim_path: str, config: dict = {}):\n \"\"\"Initialize the ROS2 Camera class\n\n Args:\n camera_prim_path (str): Path to the camera prim. Global path when it starts with `/`, else local to vehicle prim path\n config (dict): A Dictionary that contains all the parameters for configuring the ROS2Camera - it can be empty or only have some of the parameters used by the ROS2Camera.\n\n Examples:\n The dictionary default parameters are\n\n >>> {\"graph_evaluator\": \"execution\", # type of the omnigraph to create (execution, push)\n >>> \"resolution\": [640, 480], # output video stream resolution in pixels [width, height]\n >>> \"types\": ['rgb', 'camera_info'], # rgb, depth, depth_pcl, instance_segmentation, semantic_segmentation, bbox_2d_tight, bbox_2d_loose, bbox_3d, camera_info\n >>> \"publish_labels\": True, # publish labels for instance_segmentation, semantic_segmentation, bbox_2d_tight, bbox_2d_loose and bbox_3d camera types\n >>> \"topic\": \"\" # base topic name for the camera (default is camera name in Isaac Sim)\n >>> \"namespace\": \"\" # namespace for the camera (default is vehicle name in Isaac Sim)\n >>> \"tf_frame_id\": \"\"} # tf frame id for the camera (default is camera name in Isaac Sim)\n \"\"\"\n\n # Initialize the Super class \"object\" attribute\n super().__init__(graph_type=\"ROS2Camera\")\n\n # Save camera path, frame id and ros topic name\n self._camera_prim_path = camera_prim_path\n self._frame_id = camera_prim_path.rpartition(\"/\")[-1] # frame_id of the camera is the last prim path part after `/`\n self._base_topic = config.get(\"topic\", \"\")\n self._namespace = config.get(\"namespace\", \"\")\n self._tf_frame_id = config.get(\"tf_frame_id\", \"\")\n\n # Process the config dictionary\n self._graph_evaluator = config.get(\"graph_evaluator\", \"execution\")\n self._resolution = config.get(\"resolution\", [640, 480])\n self._types = np.array(config.get(\"types\", ['rgb', 'camera_info']))\n self._publish_labels = config.get(\"publish_labels\", True)\n\n def initialize(self, vehicle: Vehicle):\n \"\"\"Method that initializes the graph of the camera.\n\n Args:\n vehicle (Vehicle): The vehicle that this graph is attached to.\n \"\"\"\n\n # Set the namespace for the camera if non is provided\n if self._namespace == \"\":\n self._namespace = f\"/{vehicle.vehicle_name}\"\n\n # Set the base topic for the camera if non is provided\n if self._base_topic == \"\":\n self._base_topic = f\"/{self._frame_id}\"\n\n # Set the tf frame id for the camera if non is provided\n if self._tf_frame_id == \"\":\n self._tf_frame_id = self._frame_id\n\n # Set the prim_path for the camera\n if self._camera_prim_path[0] != '/':\n self._camera_prim_path = f\"{vehicle.prim_path}/{self._camera_prim_path}\"\n\n # Create camera prism\n if not is_prim_path_valid(self._camera_prim_path):\n carb.log_error(f\"Cannot create ROS2 Camera graph, the camera prim path \\\"{self._camera_prim_path}\\\" is not valid\")\n return\n\n # Set the prim paths for camera and tf graphs\n graph_path = f\"{self._camera_prim_path}_pub\"\n\n # Graph configuration\n if self._graph_evaluator == \"execution\":\n graph_specs = {\n \"graph_path\": graph_path,\n \"evaluator_name\": \"execution\",\n }\n elif self._graph_evaluator == \"push\":\n graph_specs = {\n \"graph_path\": graph_path,\n \"evaluator_name\": \"push\",\n \"pipeline_stage\": og.GraphPipelineStage.GRAPH_PIPELINE_STAGE_ONDEMAND,\n }\n else:\n carb.log_error(f\"Cannot create ROS2 Camera graph, graph evaluator type \\\"{self._graph_evaluator}\\\" is not valid\")\n return\n\n # Creating a graph edit configuration with cameraHelper nodes to generate ROS image publishers\n keys = og.Controller.Keys\n graph_config = {\n keys.CREATE_NODES: [\n (\"on_tick\", \"omni.graph.action.OnTick\"),\n (\"create_viewport\", \"omni.isaac.core_nodes.IsaacCreateViewport\"),\n (\"get_render_product\", \"omni.isaac.core_nodes.IsaacGetViewportRenderProduct\"),\n (\"set_viewport_resolution\", \"omni.isaac.core_nodes.IsaacSetViewportResolution\"),\n (\"set_camera\", \"omni.isaac.core_nodes.IsaacSetCameraOnRenderProduct\"),\n ],\n keys.CONNECT: [\n (\"on_tick.outputs:tick\", \"create_viewport.inputs:execIn\"),\n (\"create_viewport.outputs:execOut\", \"get_render_product.inputs:execIn\"),\n (\"create_viewport.outputs:viewport\", \"get_render_product.inputs:viewport\"),\n (\"create_viewport.outputs:execOut\", \"set_viewport_resolution.inputs:execIn\"),\n (\"create_viewport.outputs:viewport\", \"set_viewport_resolution.inputs:viewport\"),\n (\"set_viewport_resolution.outputs:execOut\", \"set_camera.inputs:execIn\"),\n (\"get_render_product.outputs:renderProductPath\", \"set_camera.inputs:renderProductPath\"),\n ],\n keys.SET_VALUES: [\n (\"create_viewport.inputs:viewportId\", 0),\n (\"create_viewport.inputs:name\", f\"{self._namespace}/{self._frame_id}\"),\n (\"set_viewport_resolution.inputs:width\", self._resolution[0]),\n (\"set_viewport_resolution.inputs:height\", self._resolution[1]),\n ],\n }\n\n # Add camerasHelper for each selected camera type\n valid_camera_type = False\n for camera_type in self._types:\n if not camera_type in [\"rgb\", \"depth\", \"depth_pcl\", \"semantic_segmentation\", \"instance_segmentation\", \"bbox_2d_tight\", \"bbox_2d_loose\", \"bbox_3d\", \"camera_info\"]:\n continue\n\n camera_helper_name = f\"camera_helper_{camera_type}\"\n\n graph_config[keys.CREATE_NODES] += [\n (camera_helper_name, \"omni.isaac.ros2_bridge.ROS2CameraHelper\")\n ]\n graph_config[keys.CONNECT] += [\n (\"set_camera.outputs:execOut\", f\"{camera_helper_name}.inputs:execIn\"),\n (\"get_render_product.outputs:renderProductPath\", f\"{camera_helper_name}.inputs:renderProductPath\")\n ]\n graph_config[keys.SET_VALUES] += [\n (f\"{camera_helper_name}.inputs:nodeNamespace\", self._namespace),\n (f\"{camera_helper_name}.inputs:frameId\", self._tf_frame_id),\n (f\"{camera_helper_name}.inputs:topicName\", f\"{self._base_topic}/{camera_type}\"),\n (f\"{camera_helper_name}.inputs:type\", camera_type)\n ]\n\n # Publish labels for specific camera types\n if self._publish_labels and camera_type in [\"semantic_segmentation\", \"instance_segmentation\", \"bbox_2d_tight\", \"bbox_2d_loose\", \"bbox_3d\"]:\n graph_config[keys.SET_VALUES] += [\n (camera_helper_name + \".inputs:enableSemanticLabels\", True),\n (camera_helper_name + \".inputs:semanticLabelsTopicName\", f\"{self._frame_id}/{camera_type}_labels\")\n ]\n\n valid_camera_type = True\n\n if not valid_camera_type:\n carb.log_error(f\"Cannot create ROS2 Camera graph, no valid camera type was selected\")\n return\n\n # Create the camera graph\n (graph, _, _, _) = og.Controller.edit(\n graph_specs,\n graph_config\n )\n\n # Connect camera to the graphs\n set_targets(\n prim=stage.get_current_stage().GetPrimAtPath(f\"{graph_path}/set_camera\"),\n attribute=\"inputs:cameraPrim\",\n target_prim_paths=[self._camera_prim_path]\n )\n\n # Run the ROS Camera graph once to generate ROS image publishers in SDGPipeline\n og.Controller.evaluate_sync(graph)\n\n # Also initialize the Super class with updated prim path (only camera graph path)\n super().initialize(graph_path)\n\n def camera_topic(self, camera_type: str) -> str:\n \"\"\"\n (str) Path to the camera topic.\n\n Args:\n camera_type (str): one of the supported camera output types\n\n Returns:\n Camera topic name (str) if the camera type exists, else empty string\n \"\"\"\n return f\"{self._namespace}{self._base_topic}/{camera_type}\" if camera_type in self._types else \"\"\n\n def camera_labels_topic(self, camera_type: str) -> str:\n \"\"\"\n (str) Path to the camera labels topic.\n\n Args:\n camera_type (str): one of the supported camera output types\n\n Returns:\n Camera labels topic name (str) if the camera type exists, else empty string\n \"\"\"\n if not self._publish_labels or \\\n not camera_type in self._types or \\\n not camera_type in [\"semantic_segmentation\", \"instance_segmentation\", \"bbox_2d_tight\", \"bbox_2d_loose\", \"bbox_3d\"]:\n return \"\"\n\n return f\"{self._namespace}{self._base_topic}/{camera_type}_labels\"\n"},"size":{"kind":"number","value":9941,"string":"9,941"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":45.896226198602704,"string":"45.896226"},"max_line_length":{"kind":"number","value":181,"string":"181"},"alphanum_fraction":{"kind":"number","value":0.5933004727297756,"string":"0.5933"}}},{"rowIdx":67,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/__init__.py"},"content":{"kind":"string","value":"\"\"\"\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved.\n\"\"\"\n\nfrom .graph import Graph\nfrom .ros2_camera import ROS2Camera\n"},"size":{"kind":"number","value":168,"string":"168"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":23.142853836735167,"string":"23.142854"},"max_line_length":{"kind":"number","value":97,"string":"97"},"alphanum_fraction":{"kind":"number","value":0.7380952337018141,"string":"0.738095"}}},{"rowIdx":68,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/graph.py"},"content":{"kind":"string","value":"\"\"\"\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved.\n\"\"\"\n__all__ = [\"Graph\"]\n\nclass Graph:\n \"\"\"The base class for implementing OmniGraphs\n\n Attributes:\n graph_prim_path\n \"\"\"\n def __init__(self, graph_type: str):\n \"\"\"Initialize Graph class\n\n Args:\n graph_type (str): A name that describes the type of graph\n \"\"\"\n self._graph_type = graph_type\n self._graph_prim_path = None\n\n def initialize(self, graph_prim_path: str):\n \"\"\"\n Method that should be implemented and called by the class that inherits the graph object.\n \"\"\"\n self._graph_prim_path = graph_prim_path\n\n @property\n def graph_type(self) -> str:\n \"\"\"\n (str) A name that describes the type of graph.\n \"\"\"\n return self._graph_type\n\n @property\n def graph_prim_path(self) -> str:\n \"\"\"\n (str) Path to the graph.\n \"\"\"\n return self._graph_prim_path\n"},"size":{"kind":"number","value":1011,"string":"1,011"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":24.299999392500016,"string":"24.299999"},"max_line_length":{"kind":"number","value":97,"string":"97"},"alphanum_fraction":{"kind":"number","value":0.5687438174394225,"string":"0.568744"}}},{"rowIdx":69,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/magnetometer.py"},"content":{"kind":"string","value":"\"\"\"\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Simulates a magnetometer. Based on the original implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Elia Tarasov\n\"\"\"\n__all__ = [\"Magnetometer\"]\n\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.sensors import Sensor\nfrom pegasus.simulator.logic.rotations import rot_ENU_to_NED, rot_FLU_to_FRD\nfrom pegasus.simulator.logic.sensors.geo_mag_utils import (\n get_mag_declination,\n get_mag_inclination,\n get_mag_strength,\n reprojection,\n)\n\nclass Magnetometer(Sensor):\n \"\"\"The class that implements a magnetometer sensor. This class inherits the base class Sensor.\n \"\"\"\n\n def __init__(self, config={}):\n \"\"\"Initialize the Magnetometer class\n\n Args:\n config (dict): A Dictionary that contains all the parameters for configuring the Magnetometer - it can be empty or only have some of the parameters used by the Magnetometer.\n \n Examples:\n The dictionary default parameters are\n\n >>> {\"noise_density\": 0.4e-3, # gauss / sqrt(hz)\n >>> \"random_walk\": 6.4e-6, # gauss * sqrt(hz)\n >>> \"bias_correlation_time\": 6.0e2, # s\n >>> \"update_rate\": 250.0} # Hz\n \"\"\"\n\n # Initialize the Super class \"object\" attributes\n super().__init__(sensor_type=\"Magnetometer\", update_rate=config.get(\"update_rate\", 250.0))\n\n # Set the noise parameters\n self._bias: np.ndarray = np.array([0.0, 0.0, 0.0])\n self._noise_density = config.get(\"noise_density\", 0.4e-3) # gauss / sqrt(hz)\n self._random_walk = config.get(\"random_walk\", 6.4e-6) # gauss * sqrt(hz)\n self._bias_correlation_time = config.get(\"bias_correlation_time\", 6.0e2) # s\n\n # Initial state measured by the Magnetometer\n self._state = {\"magnetic_field\": np.zeros((3,))}\n\n @property\n def state(self):\n \"\"\"\n (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time\n \"\"\"\n return self._state\n\n @Sensor.update_at_rate\n def update(self, state: State, dt: float):\n \"\"\"Method that implements the logic of a magnetometer. In this method we start by computing the projection\n of the vehicle body frame such in the elipsoidal model of the earth in order to get its current latitude and \n longitude. From here the declination and inclination are computed and used to get the strength of the magnetic\n field, expressed in the inertial frame of reference (in ENU convention). This magnetic field is then rotated \n to the body frame such that it becomes expressed in a FRD body frame relative to a NED inertial reference frame.\n (The convention adopted by PX4). Random noise and bias are added to this magnetic field.\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n (dict) A dictionary containing the current state of the sensor (the data produced by the sensor)\n \"\"\"\n\n # Get the latitude and longitude from the current state\n latitude, longitude = reprojection(state.position, np.radians(self._origin_lat), np.radians(self._origin_lon))\n\n # Magnetic declination and inclination (radians)\n declination_rad: float = np.radians(get_mag_declination(np.degrees(latitude), np.degrees(longitude)))\n inclination_rad: float = np.radians(get_mag_inclination(np.degrees(latitude), np.degrees(longitude)))\n\n # Compute the magnetic strength (10^5xnanoTesla)\n strength_ga: float = 0.01 * get_mag_strength(np.degrees(latitude), np.degrees(longitude))\n\n # Compute the Magnetic filed components according to: http://geomag.nrcan.gc.ca/mag_fld/comp-en.php\n H: float = strength_ga * np.cos(inclination_rad)\n Z: float = np.tan(inclination_rad) * H\n X: float = H * np.cos(declination_rad)\n Y: float = H * np.sin(declination_rad)\n\n # Magnetic field of a body following a front-left-up (FLU) convention expressed in a East-North-Up (ENU) inertial frame\n magnetic_field_inertial: np.ndarray = np.array([X, Y, Z])\n\n # Rotate the magnetic field vector such that it expresses a field of a body frame according to the front-right-down (FRD)\n # expressed in a North-East-Down (NED) inertial frame (the standard used in magnetometer units)\n attitude_flu_enu = Rotation.from_quat(state.attitude)\n\n # Rotate the magnetic field from the inertial frame to the body frame of reference according to the FLU frame convention\n rot_body_to_world = rot_ENU_to_NED * attitude_flu_enu * rot_FLU_to_FRD.inv()\n\n # The magnetic field expressed in the body frame according to the front-right-down (FRD) convention\n magnetic_field_body = rot_body_to_world.inv().apply(magnetic_field_inertial)\n\n # -------------------------------\n # Add noise to the magnetic field\n # -------------------------------\n tau = self._bias_correlation_time\n\n # Discrete-time standard deviation equivalent to an \"integrating\" sampler with integration time dt.\n sigma_d: float = 1 / np.sqrt(dt) * self._noise_density\n sigma_b: float = self._random_walk\n\n # Compute exact covariance of the process after dt [Maybeck 4-114].\n sigma_b_d: float = np.sqrt(-sigma_b * sigma_b * tau / 2.0 * (np.exp(-2.0 * dt / tau) - 1.0))\n\n # Compute state-transition.\n phi_d: float = np.exp(-1.0 / tau * dt)\n\n # Add the noise to the magnetic field\n magnetic_field_noisy: np.ndarray = np.zeros((3,))\n for i in range(3):\n self._bias[i] = phi_d * self._bias[i] + sigma_b_d * np.random.randn()\n magnetic_field_noisy[i] = magnetic_field_body[i] + sigma_d * np.random.randn() + self._bias[i]\n\n # Add the values to the dictionary and return it\n self._state = {\"magnetic_field\": [magnetic_field_noisy[0], magnetic_field_noisy[1], magnetic_field_noisy[2]]}\n\n return self._state\n"},"size":{"kind":"number","value":6384,"string":"6,384"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":48.11538424526628,"string":"48.115384"},"max_line_length":{"kind":"number","value":185,"string":"185"},"alphanum_fraction":{"kind":"number","value":0.6495927317278206,"string":"0.649593"}}},{"rowIdx":70,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/geo_mag_utils.py"},"content":{"kind":"string","value":"\"\"\"\n| File: geo_mag_utils.py\n| Description: Provides utilities for computing latitude, longitude, and magnetic strength\ngiven the position of the vehicle in the simulated world. These computations and table constants are in agreement\nwith the PX4 stil_gazebo implementation (https://github.com/PX4/PX4-SITL_gazebo). Therefore, PX4 should behave similarly \nto a gazebo-based simulation.\n\"\"\"\nimport numpy as np\n\n# Declare which functions are visible from this file\n__all__ = [\"get_mag_declination\", \"get_mag_inclination\", \"get_mag_strength\", \"reprojection\", \"GRAVITY_VECTOR\"]\n\n# --------------------------------------------------------------------\n# Magnetic field data from WMM2018 (10^5xnanoTesla (N, E D) n-frame )\n# --------------------------------------------------------------------\n\n# Declination data in degrees\nDECLINATION_TABLE = [\n [ 47,46,45,43,42,41,39,37,33,29,23,16,10,4,-1,-6,-10,-15,-20,-27,-34,-42,-49,-56,-62,-67,-72,-74,-75,-73,-61,-22,26,42,47,48,47 ],\n [ 31,31,31,30,30,30,30,29,27,24,18,11,3,-4,-9,-13,-15,-18,-21,-27,-33,-40,-47,-52,-56,-57,-56,-52,-44,-30,-14,2,14,22,27,30,31 ],\n [ 22,23,23,23,22,22,22,23,22,19,13,5,-4,-12,-17,-20,-22,-22,-23,-25,-30,-36,-41,-45,-46,-44,-39,-31,-21,-11,-3,4,10,15,19,21,22 ],\n [ 17,17,17,18,17,17,17,17,16,13,8,-1,-10,-18,-22,-25,-26,-25,-22,-20,-21,-25,-29,-32,-31,-28,-23,-16,-9,-3,0,4,7,11,14,16,17 ],\n [ 13,13,14,14,14,13,13,12,11,9,3,-5,-14,-20,-24,-25,-24,-21,-17,-12,-9,-11,-14,-17,-18,-16,-12,-8,-3,-0,1,3,6,8,11,12,13 ],\n [ 11,11,11,11,11,10,10,10,9,6,-0,-8,-15,-21,-23,-22,-19,-15,-10,-5,-2,-2,-4,-7,-9,-8,-7,-4,-1,1,1,2,4,7,9,10,11 ],\n [ 10,9,9,9,9,9,9,8,7,3,-3,-10,-16,-20,-20,-18,-14,-9,-5,-2,1,2,0,-2,-4,-4,-3,-2,-0,0,0,1,3,5,7,9,10 ],\n [ 9,9,9,9,9,9,9,8,6,1,-4,-11,-16,-18,-17,-14,-10,-5,-2,-0,2,3,2,0,-1,-2,-2,-1,-0,-1,-1,-1,1,3,6,8,9 ],\n [ 8,9,9,10,10,10,10,8,5,0,-6,-12,-15,-16,-15,-11,-7,-4,-1,1,3,4,3,2,1,0,-0,-0,-1,-2,-3,-4,-2,0,3,6,8 ],\n [ 7,9,10,11,12,12,12,9,5,-1,-7,-13,-15,-15,-13,-10,-6,-3,0,2,3,4,4,4,3,2,1,0,-1,-3,-5,-6,-6,-3,0,4,7 ],\n [ 5,8,11,13,14,15,14,11,5,-2,-9,-15,-17,-16,-13,-10,-6,-3,0,3,4,5,6,6,6,5,4,2,-1,-5,-8,-9,-9,-6,-3,1,5 ],\n [ 3,8,11,15,17,17,16,12,5,-4,-12,-18,-19,-18,-16,-12,-8,-4,-0,3,5,7,9,10,10,9,7,4,-1,-6,-10,-12,-12,-9,-5,-1,3 ],\n [ 3,8,12,16,19,20,18,13,4,-8,-18,-24,-25,-23,-20,-16,-11,-6,-1,3,7,11,14,16,17,17,14,8,-0,-8,-13,-15,-14,-11,-7,-2,3 ]]\n\n# Inclination data in degrees\nINCLINATION_TABLE = [\n [ -78,-76,-74,-72,-70,-68,-65,-63,-60,-57,-55,-54,-54,-55,-56,-57,-58,-59,-59,-59,-59,-60,-61,-63,-66,-69,-73,-76,-79,-83,-86,-87,-86,-84,-82,-80,-78 ],\n [ -72,-70,-68,-66,-64,-62,-60,-57,-54,-51,-49,-48,-49,-51,-55,-58,-60,-61,-61,-61,-60,-60,-61,-63,-66,-69,-72,-76,-78,-80,-81,-80,-79,-77,-76,-74,-72 ],\n [ -64,-62,-60,-59,-57,-55,-53,-50,-47,-44,-41,-41,-43,-47,-53,-58,-62,-65,-66,-65,-63,-62,-61,-63,-65,-68,-71,-73,-74,-74,-73,-72,-71,-70,-68,-66,-64 ],\n [ -55,-53,-51,-49,-46,-44,-42,-40,-37,-33,-30,-30,-34,-41,-48,-55,-60,-65,-67,-68,-66,-63,-61,-61,-62,-64,-65,-66,-66,-65,-64,-63,-62,-61,-59,-57,-55 ],\n [ -42,-40,-37,-35,-33,-30,-28,-25,-22,-18,-15,-16,-22,-31,-40,-48,-55,-59,-62,-63,-61,-58,-55,-53,-53,-54,-55,-55,-54,-53,-51,-51,-50,-49,-47,-45,-42 ],\n [ -25,-22,-20,-17,-15,-12,-10,-7,-3,1,3,2,-5,-16,-27,-37,-44,-48,-50,-50,-48,-44,-41,-38,-38,-38,-39,-39,-38,-37,-36,-35,-35,-34,-31,-28,-25 ],\n [ -5,-2,1,3,5,8,10,13,16,20,21,19,12,2,-10,-20,-27,-30,-30,-29,-27,-23,-19,-17,-17,-17,-18,-18,-17,-16,-16,-16,-16,-15,-12,-9,-5 ],\n [ 15,18,21,22,24,26,29,31,34,36,37,34,28,20,10,2,-3,-5,-5,-4,-2,2,5,7,8,7,7,6,7,7,7,6,5,6,8,11,15 ],\n [ 31,34,36,38,39,41,43,46,48,49,49,46,42,36,29,24,20,19,20,21,23,25,28,30,30,30,29,29,29,29,28,27,25,25,26,28,31 ],\n [ 43,45,47,49,51,53,55,57,58,59,59,56,53,49,45,42,40,40,40,41,43,44,46,47,47,47,47,47,47,47,46,44,42,41,40,42,43 ],\n [ 53,54,56,57,59,61,64,66,67,68,67,65,62,60,57,55,55,54,55,56,57,58,59,59,60,60,60,60,60,60,59,57,55,53,52,52,53 ],\n [ 62,63,64,65,67,69,71,73,75,75,74,73,70,68,67,66,65,65,65,66,66,67,68,68,69,70,70,71,71,70,69,67,65,63,62,62,62 ],\n [ 71,71,72,73,75,77,78,80,81,81,80,79,77,76,74,73,73,73,73,73,73,74,74,75,76,77,78,78,78,78,77,75,73,72,71,71,71 ]]\n\n# Strength data in centi-Tesla\nSTRENGTH_TABLE = [\n [ 62,60,58,56,54,52,49,46,43,41,38,36,34,32,31,31,30,30,30,31,33,35,38,42,46,51,55,59,62,64,66,67,67,66,65,64,62 ],\n [ 59,56,54,52,50,47,44,41,38,35,32,29,28,27,26,26,26,25,25,26,28,30,34,39,44,49,54,58,61,64,65,66,65,64,63,61,59 ],\n [ 54,52,49,47,45,42,40,37,34,30,27,25,24,24,24,24,24,24,24,24,25,28,32,37,42,48,52,56,59,61,62,62,62,60,59,56,54 ],\n [ 49,47,44,42,40,37,35,33,30,28,25,23,22,23,23,24,25,25,26,26,26,28,31,36,41,46,51,54,56,57,57,57,56,55,53,51,49 ],\n [ 43,41,39,37,35,33,32,30,28,26,25,23,23,23,24,25,26,28,29,29,29,30,32,36,40,44,48,51,52,52,51,51,50,49,47,45,43 ],\n [ 38,36,35,33,32,31,30,29,28,27,26,25,24,24,25,26,28,30,31,32,32,32,33,35,38,42,44,46,47,46,45,45,44,43,41,40,38 ],\n [ 34,33,32,32,31,31,31,30,30,30,29,28,27,27,27,28,29,31,32,33,33,33,34,35,37,39,41,42,43,42,41,40,39,38,36,35,34 ],\n [ 33,33,32,32,33,33,34,34,35,35,34,33,32,31,30,30,31,32,33,34,35,35,36,37,38,40,41,42,42,41,40,39,37,36,34,33,33 ],\n [ 34,34,34,35,36,37,39,40,41,41,40,39,37,35,35,34,35,35,36,37,38,39,40,41,42,43,44,45,45,45,43,41,39,37,35,34,34 ],\n [ 37,37,38,39,41,42,44,46,47,47,46,45,43,41,40,39,39,40,41,41,42,43,45,46,47,48,49,50,50,50,48,46,43,41,39,38,37 ],\n [ 42,42,43,44,46,48,50,52,53,53,52,51,49,47,45,45,44,44,45,46,46,47,48,50,51,53,54,55,56,55,54,52,49,46,44,43,42 ],\n [ 48,48,49,50,52,53,55,56,57,57,56,55,53,51,50,49,48,48,48,49,49,50,51,53,55,56,58,59,60,60,58,56,54,52,50,49,48 ],\n [ 54,54,54,55,56,57,58,58,59,58,58,57,56,54,53,52,51,51,51,51,52,53,54,55,57,58,60,61,62,61,61,59,58,56,55,54,54 ]]\n\nSAMPLING_RES = 10.0\nSAMPLING_MIN_LAT = -60 # deg\nSAMPLING_MAX_LAT = 60 # deg\nSAMPLING_MIN_LON = -180 # deg\nSAMPLING_MAX_LON = 180 # deg\n\nEARTH_RADIUS = 6353000.0 # meters\n\n# Gravity vector expressed in ENU\nGRAVITY_VECTOR = np.array([0.0, 0.0, -9.80665]) # m/s^2\n\n\ndef get_lookup_table_index(val: int, min: int, max: int):\n\n # for the rare case of hitting the bounds exactly\n # the rounding logic wouldn't fit, so enforce it.\n # limit to table bounds - required for maxima even when table spans full globe range\n # limit to (table bounds - 1) because bilinear interpolation requires checking (index + 1)\n val = np.clip(val, min, max - SAMPLING_RES)\n return int((-min + val) / SAMPLING_RES)\n\n\ndef get_table_data(lat: float, lon: float, table):\n\n # If the values exceed valid ranges, return zero as default\n # as we have no way of knowing what the closest real value\n # would be.\n if lat < -90.0 or lat > 90.0 or lon < -180.0 or lon > 180.0:\n return 0.0\n\n # round down to nearest sampling resolution\n min_lat = int(lat / SAMPLING_RES) * SAMPLING_RES\n min_lon = int(lon / SAMPLING_RES) * SAMPLING_RES\n\n # find index of nearest low sampling point\n min_lat_index = get_lookup_table_index(min_lat, SAMPLING_MIN_LAT, SAMPLING_MAX_LAT)\n min_lon_index = get_lookup_table_index(min_lon, SAMPLING_MIN_LON, SAMPLING_MAX_LON)\n\n data_sw = table[min_lat_index][min_lon_index]\n data_se = table[min_lat_index][min_lon_index + 1]\n data_ne = table[min_lat_index + 1][min_lon_index + 1]\n data_nw = table[min_lat_index + 1][min_lon_index]\n\n # perform bilinear interpolation on the four grid corners\n lat_scale = np.clip((lat - min_lat) / SAMPLING_RES, 0.0, 1.0)\n lon_scale = np.clip((lon - min_lon) / SAMPLING_RES, 0.0, 1.0)\n\n data_min = lon_scale * (data_se - data_sw) + data_sw\n data_max = lon_scale * (data_ne - data_nw) + data_nw\n\n return lat_scale * (data_max - data_min) + data_min\n\n\ndef get_mag_declination(latitude: float, longitude: float):\n return get_table_data(latitude, longitude, DECLINATION_TABLE)\n\n\ndef get_mag_inclination(latitude: float, longitude: float):\n return get_table_data(latitude, longitude, INCLINATION_TABLE)\n\n\ndef get_mag_strength(latitude: float, longitude: float):\n return get_table_data(latitude, longitude, STRENGTH_TABLE)\n\n\ndef reprojection(position: np.ndarray, origin_lat=-999, origin_long=-999):\n \"\"\"\n Compute the latitude and longitude coordinates from a local position\n \"\"\"\n\n # reproject local position to gps coordinates\n x_rad: float = position[1] / EARTH_RADIUS # north\n y_rad: float = position[0] / EARTH_RADIUS # east\n c: float = np.sqrt(x_rad * x_rad + y_rad * y_rad)\n sin_c: float = np.sin(c)\n cos_c: float = np.cos(c)\n\n if c != 0.0:\n latitude_rad = np.arcsin(cos_c * np.sin(origin_lat) + (x_rad * sin_c * np.cos(origin_lat)) / c)\n longitude_rad = origin_long + np.arctan2(y_rad * sin_c, c * np.cos(origin_lat) * cos_c - x_rad * np.sin(origin_lat) * sin_c)\n else:\n latitude_rad = origin_lat\n longitude_rad = origin_long\n\n return latitude_rad, longitude_rad\n"},"size":{"kind":"number","value":8992,"string":"8,992"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":58.953332940311114,"string":"58.953333"},"max_line_length":{"kind":"number","value":156,"string":"156"},"alphanum_fraction":{"kind":"number","value":0.5907473308951571,"string":"0.590747"}}},{"rowIdx":71,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/sensor.py"},"content":{"kind":"string","value":"\"\"\"\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of the Sensor class which is used as the base for all the sensors.\n\"\"\"\n__all__ = [\"Sensor\"]\n\nfrom pegasus.simulator.logic.state import State\n\nclass Sensor:\n \"\"\"The base class for implementing a sensor\n\n Attributes:\n update_period (float): The period for each sensor update: update_period = 1 / update_rate (in s).\n origin_lat (float): The latitude of the origin of the world in degrees (might get used by some sensors).\n origin_lon (float): The longitude of the origin of the world in degrees (might get used by some sensors).\n origin_alt (float): The altitude of the origin of the world relative to sea water level (might get used by some sensors)\n \"\"\"\n def __init__(self, sensor_type: str, update_rate: float):\n \"\"\"Initialize the Sensor class\n\n Args:\n sensor_type (str): A name that describes the type of sensor\n update_rate (float): The rate at which the data in the sensor should be refreshed (in Hz)\n \"\"\"\n\n # Set the sensor type and update rate\n self._sensor_type = sensor_type\n self._update_rate = update_rate\n self._update_period = 1.0 / self._update_rate\n\n # Auxiliar variables used to control whether to update the sensor or not given the time elapsed\n self._first_update = True\n self._total_time = 0.0\n\n # Set the \"configuration of the world\" - some sensors might need it\n self._origin_lat = -999\n self._origin_lon = -999\n self._origin_alt = 0.0\n\n def initialize(self, origin_lat, origin_lon, origin_alt):\n \"\"\"Method that initializes the sensor latitude, longitude and altitude attributes.\n \n Note:\n Given that some sensors require the knowledge of the latitude, longitude and altitude of the [0, 0, 0] coordinate\n of the world, then we might as well just save this information for whatever sensor that comes\n \n Args:\n origin_lat (float): The latitude of the origin of the world in degrees (might get used by some sensors).\n origin_lon (float): The longitude of the origin of the world in degrees (might get used by some sensors).\n origin_alt (float): The altitude of the origin of the world relative to sea water level (might get used by some sensors).\n \"\"\"\n self._origin_lat = origin_lat\n self._origin_lon = origin_lon\n self._origin_alt = origin_alt\n\n def set_update_rate(self, update_rate: float):\n \"\"\"Method that changes the update rate and period of the sensor\n\n Args:\n update_rate (float): The new rate at which the data in the sensor should be refreshed (in Hz)\n \"\"\"\n self._update_rate = update_rate\n self._update_period = 1.0 / self._update_rate\n\n def update_at_rate(fnc):\n \"\"\"Decorator function used to check if the time elapsed between the last sensor update call and the current \n sensor update call is higher than the defined update_rate of the sensor. If so, we need to actually compute new\n values to simulate a measurement of the sensor at a given rate.\n\n Args:\n fnc (function): The function that we want to enforce a specific update rate.\n\n Examples:\n >>> class GPS(Sensor):\n >>> @Sensor.update_at_rate\n >>> def update(self):\n >>> (do some logic here)\n\n Returns:\n [None, Dict]: This decorator function returns None if there was no data to be produced by the sensor at the\n specified timestamp or a dict with the current state of the sensor otherwise.\n \"\"\"\n \n # \n\n # Define a wrapper function so that the \"self\" of the object can be passed to the function as well\n def wrapper(self, state: State, dt: float):\n\n # Add the total time passed between the last time the sensor was updated and the current call\n self._total_time += dt\n\n # If it is time to update the sensor data, then just call the update function of the sensor\n if self._total_time >= self._update_period or self._first_update:\n\n # Result of the update function for the sensor\n result = fnc(self, state, self._total_time)\n\n # Reset the auxiliar counter variables\n self._first_update = False\n self._total_time = 0.0\n\n return result\n return None\n return wrapper\n\n @property\n def sensor_type(self):\n \"\"\"\n (str) A name that describes the type of sensor.\n \"\"\"\n return self._sensor_type\n\n @property\n def update_rate(self):\n \"\"\"\n (float) The rate at which the data in the sensor should be refreshed (in Hz).\n \"\"\"\n return self._update_rate\n\n @property\n def state(self):\n \"\"\"\n (dict) A dictionary which contains the data produced by the sensor at any given time.\n \"\"\"\n return None\n\n def update(self, state: State, dt: float):\n \"\"\"Method that should be implemented by the class that inherits Sensor. This is where the actual implementation\n of the sensor should be performed.\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n (dict) A dictionary containing the current state of the sensor (the data produced by the sensor)\n \"\"\"\n pass\n\n def config_from_dict(self, config_dict):\n \"\"\"Method that should be implemented by the class that inherits Sensor. This is where the configuration of the \n sensor based on a dictionary input should be performed.\n\n Args:\n config_dict (dict): A dictionary containing the configurations of the sensor\n \"\"\"\n pass\n"},"size":{"kind":"number","value":6081,"string":"6,081"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":39.81879167906851,"string":"39.818792"},"max_line_length":{"kind":"number","value":133,"string":"133"},"alphanum_fraction":{"kind":"number","value":0.6276928135787382,"string":"0.627693"}}},{"rowIdx":72,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/barometer.py"},"content":{"kind":"string","value":"\"\"\"\n| File: barometer.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Simulates a barometer. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Elia Tarasov.\n| References: Both the original implementation provided in the gazebo based simulation and this one are based on the following article - 'A brief summary of atmospheric modeling', Cavcar, M., http://fisicaatmo.at.fcen.uba.ar/practicas/ISAweb.pdf\n\"\"\"\n__all__ = [\"Barometer\"]\n\nimport numpy as np\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.sensors import Sensor\nfrom pegasus.simulator.logic.sensors.geo_mag_utils import GRAVITY_VECTOR\n\nDEFAULT_HOME_ALT_AMSL = 488.0\n\nclass Barometer(Sensor):\n \"\"\"The class that implements a barometer sensor. This class inherits the base class Sensor.\n \"\"\"\n\n def __init__(self, config={}):\n \"\"\"Initialize the Barometer class\n\n Args:\n config (dict): A Dictionary that contains all the parameters for configuring the Barometer - it can be empty or only have some of the parameters used by the Barometer.\n \n Examples:\n The dictionary default parameters are\n\n >>> {\"temperature_msl\": 288.15, # temperature at MSL [K] (15 [C])\n >>> \"pressure_msl\": 101325.0, # pressure at MSL [Pa]\n >>> \"lapse_rate\": 0.0065, # reduction in temperature with altitude for troposphere [K/m]\n >>> \"air_density_msl\": 1.225, # air density at MSL [kg/m^3]\n >>> \"absolute_zero\": -273.15, # [C]\n >>> \"drift_pa_per_sec\": 0.0, # Pa\n >>> \"update_rate\": 250.0} # Hz\n \"\"\"\n\n # Initialize the Super class \"object\" attributes\n super().__init__(sensor_type=\"Barometer\", update_rate=config.get(\"update_rate\", 250.0))\n\n self._z_start: float = None\n\n # Setup the default home altitude (aka the altitude at the [0.0, 0.0, 0.0] coordinate on the simulated world)\n # If desired, the user can override this default by calling the initialize() method defined inside the Sensor\n # implementation\n self._origin_alt = DEFAULT_HOME_ALT_AMSL\n\n # Define the constants for the barometer\n # International standard atmosphere (troposphere model - valid up to 11km) see [1]\n self._TEMPERATURE_MSL: float = config.get(\"temperature_msl\", 288.15) # temperature at MSL [K] (15 [C])\n self._PRESSURE_MSL: float = config.get(\"pressure_msl\", 101325.0) # pressure at MSL [Pa]\n self._LAPSE_RATE: float = config.get(\n \"lapse_rate\", 0.0065\n ) # reduction in temperature with altitude for troposphere [K/m]\n self._AIR_DENSITY_MSL: float = config.get(\"air_density_msl\", 1.225) # air density at MSL [kg/m^3]\n self._ABSOLUTE_ZERO_C: float = config.get(\"absolute_zero\", -273.15) # [C]\n\n # Set the drift for the sensor\n self._baro_drift_pa_per_sec: float = config.get(\"drift_pa_per_sec\", 0.0)\n\n # Auxiliar variables for generating the noise\n self._baro_rnd_use_last: bool = False\n self._baro_rnd_y2: float = 0.0\n self._baro_drift_pa: float = 0.0\n \n\n # Save the current state measured by the Baramoter\n self._state = {\"absolute_pressure\": 0.0, \"pressure_altitude\": 0.0, \"temperature\": 0.0}\n\n @property\n def state(self):\n \"\"\"\n (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time\n \"\"\"\n return self._state\n\n @Sensor.update_at_rate\n def update(self, state: State, dt: float):\n \"\"\"Method that implements the logic of a barometer. In this method we compute the relative altitude of the vehicle\n relative to the origin's altitude. Aditionally, we compute the actual altitude of the vehicle, local temperature and\n absolute presure, based on the reference - [A brief summary of atmospheric modeling, Cavcar, M., http://fisicaatmo.at.fcen.uba.ar/practicas/ISAweb.pdf]\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n (dict) A dictionary containing the current state of the sensor (the data produced by the sensor)\n \"\"\"\n\n # Set the initial altitude if not yet defined\n if self._z_start is None:\n self._z_start = state.position[2]\n\n # Compute the temperature at the current altitude\n alt_rel: float = state.position[2] - self._z_start\n alt_amsl: float = self._origin_alt + alt_rel\n temperature_local: float = self._TEMPERATURE_MSL - self._LAPSE_RATE * alt_amsl\n\n # Compute the absolute pressure at local temperature\n pressure_ratio: float = np.power(self._TEMPERATURE_MSL / temperature_local, 5.2561)\n absolute_pressure: float = self._PRESSURE_MSL / pressure_ratio\n\n # Generate a Gaussian noise sequence using polar form of Box-Muller transformation\n # Honestly, this is overkill and will get replaced by numpys random.randn. \n if not self._baro_rnd_use_last:\n\n w: float = 1.0\n\n while w >= 1.0:\n x1: float = 2.0 * np.random.randn() - 1.0\n x2: float = 2.0 * np.random.randn() - 1.0\n w = (x1 * x1) + (x2 * x2)\n\n w = np.sqrt((-2.0 * np.log(w)) / w)\n y1: float = x1 * w\n self._baro_rnd_y2 = x2 * w\n self._baro_rnd_use_last = True\n else:\n y1: float = self._baro_rnd_y2\n self._baro_rnd_use_last = False\n\n # Apply noise and drift\n abs_pressure_noise: float = y1 # 1 Pa RMS noise\n self._baro_drift_pa = self._baro_drift_pa + (self._baro_drift_pa_per_sec * dt) # Update the drift\n absolute_pressure_noisy: float = absolute_pressure + abs_pressure_noise + self._baro_drift_pa_per_sec\n\n # Convert to hPa (Note: 1 hPa = 100 Pa)\n absolute_pressure_noisy_hpa: float = absolute_pressure_noisy * 0.01\n\n # Compute air density at local temperature\n density_ratio: float = np.power(self._TEMPERATURE_MSL / temperature_local, 4.256)\n air_density: float = self._AIR_DENSITY_MSL / density_ratio\n\n # Compute pressure altitude including effect of pressure noise\n pressure_altitude: float = alt_amsl - (abs_pressure_noise + self._baro_drift_pa) / (np.linalg.norm(GRAVITY_VECTOR) * air_density)\n #pressure_altitude: float = alt_amsl - (abs_pressure_noise) / (np.linalg.norm(GRAVITY_VECTOR) * air_density)\n\n # Compute temperature in celsius\n temperature_celsius: float = temperature_local + self._ABSOLUTE_ZERO_C\n\n # Add the values to the dictionary and return it\n self._state = {\n \"absolute_pressure\": absolute_pressure_noisy_hpa,\n \"pressure_altitude\": pressure_altitude,\n \"temperature\": temperature_celsius,\n }\n\n return self._state\n"},"size":{"kind":"number","value":7189,"string":"7,189"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":46.61589373102057,"string":"46.615894"},"max_line_length":{"kind":"number","value":245,"string":"245"},"alphanum_fraction":{"kind":"number","value":0.6260954234766872,"string":"0.626095"}}},{"rowIdx":73,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/gps.py"},"content":{"kind":"string","value":"\"\"\"\n| File: gps.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Simulates a gps. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Amy Wagoner and Nuno Marques\n\"\"\"\n__all__ = [\"GPS\"]\n\nimport numpy as np\nfrom pegasus.simulator.logic.sensors import Sensor\nfrom pegasus.simulator.logic.sensors.geo_mag_utils import reprojection\n\n# TODO - Introduce delay on the GPS data\n\nclass GPS(Sensor):\n \"\"\"The class that implements a GPS sensor. This class inherits the base class Sensor.\n \"\"\"\n\n def __init__(self, config={}):\n \"\"\"Initialize the GPS class.\n\n Args:\n config (dict): A Dictionary that contains all the parameters for configuring the GPS - it can be empty or only have some of the parameters used by the GPS.\n \n Examples:\n The dictionary default parameters are\n\n >>> {\"fix_type\": 3,\n >>> \"eph\": 1.0,\n >>> \"epv\": 1.0,\n >>> \"sattelites_visible\": 10,\n >>> \"gps_xy_random_walk\": 2.0, # (m/s) / sqrt(hz)\n >>> \"gps_z_random_walk\": 4.0, # (m/s) / sqrt(hz)\n >>> \"gps_xy_noise_density\": 2.0e-4, # (m) / sqrt(hz)\n >>> \"gps_z_noise_density\": 4.0e-4, # (m) / sqrt(hz)\n >>> \"gps_vxy_noise_density\": 0.2, # (m/s) / sqrt(hz)\n >>> \"gps_vz_noise_density\": 0.4, # (m/s) / sqrt(hz)\n >>> \"gps_correlation_time\": 60, # s\n >>> \"update_rate\": 1.0 # Hz\n >>> }\n \"\"\"\n\n # Initialize the Super class \"object\" attributes\n super().__init__(sensor_type=\"GPS\", update_rate=config.get(\"update_rate\", 250.0))\n\n # Define the GPS simulated/fixed values\n self._fix_type = config.get(\"fix_type\", 3)\n self._eph = config.get(\"eph\", 1.0)\n self._epv = config.get(\"epv\", 1.0)\n self._sattelites_visible = config.get(\"sattelites_visible\", 10)\n\n # Parameters for GPS random walk\n self._random_walk_gps = np.array([0.0, 0.0, 0.0])\n self._gps_xy_random_walk = config.get(\"gps_xy_random_walk\", 2.0) # (m/s) / sqrt(hz)\n self._gps_z_random_walk = config.get(\"gps_z_random_walk\", 4.0) # (m/s) / sqrt(hz)\n\n # Parameters for the position noise\n self._noise_gps_pos = np.array([0.0, 0.0, 0.0])\n self._gps_xy_noise_density = config.get(\"gps_xy_noise_density\", 2.0e-4) # (m) / sqrt(hz)\n self._gps_z_noise_density = config.get(\"gps_z_noise_density\", 4.0e-4) # (m) / sqrt(hz)\n\n # Parameters for the velocity noise\n self._noise_gps_vel = np.array([0.0, 0.0, 0.0])\n self._gps_vxy_noise_density = config.get(\"gps_vxy_noise_density\", 0.2) # (m/s) / sqrt(hz)\n self._gps_vz_noise_density = config.get(\"gps_vz_noise_density\", 0.4) # (m/s) / sqrt(hz)\n\n # Parameters for the GPS bias\n self._gps_bias = np.array([0.0, 0.0, 0.0])\n self._gps_correlation_time = config.get(\"gps_correlation_time\", 60)\n\n # Save the current state measured by the GPS (and initialize at the origin)\n self._state = {\n \"latitude\": np.radians(self._origin_lat),\n \"longitude\": np.radians(self._origin_lon),\n \"altitude\": self._origin_alt,\n \"eph\": 1.0,\n \"epv\": 1.0,\n \"speed\": 0.0,\n \"velocity_north\": 0.0,\n \"velocity_east\": 0.0,\n \"velocity_down\": 0.0,\n # Constant values\n \"fix_type\": self._fix_type,\n \"eph\": self._eph,\n \"epv\": self._epv,\n \"cog\": 0.0,\n \"sattelites_visible\": self._sattelites_visible,\n \"latitude_gt\": np.radians(self._origin_lat),\n \"longitude_gt\": np.radians(self._origin_lon),\n \"altitude_gt\": self._origin_alt,\n }\n\n @property\n def state(self):\n \"\"\"\n (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time\n \"\"\"\n return self._state\n\n @Sensor.update_at_rate\n def update(self, state: np.ndarray, dt: float):\n \"\"\"Method that implements the logic of a gps. In this method we start by generating the GPS bias terms which are then\n added to the real position of the vehicle, expressed in ENU inertial frame. This position affected by noise\n is reprojected in order to obtain the corresponding latitude and longitude. Additionally, to the linear velocity, noise\n is added.\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n (dict) A dictionary containing the current state of the sensor (the data produced by the sensor)\n \"\"\"\n\n # Update noise parameters\n self._random_walk_gps[0] = self._gps_xy_random_walk * np.sqrt(dt) * np.random.randn()\n self._random_walk_gps[1] = self._gps_xy_random_walk * np.sqrt(dt) * np.random.randn()\n self._random_walk_gps[2] = self._gps_z_random_walk * np.sqrt(dt) * np.random.randn()\n\n self._noise_gps_pos[0] = self._gps_xy_noise_density * np.sqrt(dt) * np.random.randn()\n self._noise_gps_pos[1] = self._gps_xy_noise_density * np.sqrt(dt) * np.random.randn()\n self._noise_gps_pos[2] = self._gps_z_noise_density * np.sqrt(dt) * np.random.randn()\n\n self._noise_gps_vel[0] = self._gps_vxy_noise_density * np.sqrt(dt) * np.random.randn()\n self._noise_gps_vel[1] = self._gps_vxy_noise_density * np.sqrt(dt) * np.random.randn()\n self._noise_gps_vel[2] = self._gps_vz_noise_density * np.sqrt(dt) * np.random.randn()\n\n # Perform GPS bias integration (using euler integration -> to be improved)\n self._gps_bias[0] = (\n self._gps_bias[0] + self._random_walk_gps[0] * dt - self._gps_bias[0] / self._gps_correlation_time\n )\n self._gps_bias[1] = (\n self._gps_bias[1] + self._random_walk_gps[1] * dt - self._gps_bias[1] / self._gps_correlation_time\n )\n self._gps_bias[2] = (\n self._gps_bias[2] + self._random_walk_gps[2] * dt - self._gps_bias[2] / self._gps_correlation_time\n )\n\n # reproject position with noise into geographic coordinates\n pos_with_noise: np.ndarray = state.position + self._noise_gps_pos + self._gps_bias\n latitude, longitude = reprojection(pos_with_noise, np.radians(self._origin_lat), np.radians(self._origin_lon))\n\n # Compute the values of the latitude and longitude without noise (for groundtruth measurements)\n latitude_gt, longitude_gt = reprojection(\n state.position, np.radians(self._origin_lat), np.radians(self._origin_lon)\n )\n\n # Add noise to the velocity expressed in the world frame\n velocity: np.ndarray = state.linear_velocity # + self._noise_gps_vel\n\n # Compute the xy speed\n speed: float = np.linalg.norm(velocity[:2])\n\n # Course over ground (NOT heading, but direction of movement),\n # 0.0..359.99 degrees. If unknown, set to: 65535 [cdeg] (type:uint16_t)\n ve = velocity[0]\n vn = velocity[1]\n cog = np.degrees(np.arctan2(ve, vn))\n\n if cog < 0.0:\n cog = cog + 360.0\n\n cog = cog * 100\n\n # Add the values to the dictionary and return it\n self._state = {\n \"latitude\": np.degrees(latitude),\n \"longitude\": np.degrees(longitude),\n \"altitude\": state.position[2] + self._origin_alt - self._noise_gps_pos[2] + self._gps_bias[2],\n \"eph\": 1.0,\n \"epv\": 1.0,\n \"speed\": speed,\n # Conversion from ENU (standard of Isaac Sim to NED - used in GPS sensors)\n \"velocity_north\": velocity[1],\n \"velocity_east\": velocity[0],\n \"velocity_down\": -velocity[2],\n # Constant values\n \"fix_type\": self._fix_type,\n \"eph\": self._eph,\n \"epv\": self._epv,\n \"cog\": 0.0, # cog,\n \"sattelites_visible\": self._sattelites_visible,\n \"latitude_gt\": latitude_gt,\n \"longitude_gt\": longitude_gt,\n \"altitude_gt\": state.position[2] + self._origin_alt,\n }\n\n return self._state\n"},"size":{"kind":"number","value":8406,"string":"8,406"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":43.48148125142073,"string":"43.481481"},"max_line_length":{"kind":"number","value":167,"string":"167"},"alphanum_fraction":{"kind":"number","value":0.5712586247238569,"string":"0.571259"}}},{"rowIdx":74,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/imu.py"},"content":{"kind":"string","value":"\"\"\"\n| File: imu.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Simulates an imu. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo)\n\"\"\"\n__all__ = [\"IMU\"]\n\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.sensors import Sensor\nfrom pegasus.simulator.logic.rotations import rot_FLU_to_FRD, rot_ENU_to_NED\nfrom pegasus.simulator.logic.sensors.geo_mag_utils import GRAVITY_VECTOR\n\n\nclass IMU(Sensor):\n \"\"\"The class that implements the IMU sensor. This class inherits the base class Sensor.\n \"\"\"\n def __init__(self, config={}):\n \"\"\"Initialize the IMU class\n\n Args:\n config (dict): A Dictionary that contains all teh parameters for configuring the IMU - it can be empty or only have some of the parameters used by the IMU.\n\n Examples:\n The dictionary default parameters are\n\n >>> {\"gyroscope\": {\n >>> \"noise_density\": 2.0 * 35.0 / 3600.0 / 180.0 * pi,\n >>> \"random_walk\": 2.0 * 4.0 / 3600.0 / 180.0 * pi,\n >>> \"bias_correlation_time\": 1.0e3,\n >>> \"turn_on_bias_sigma\": 0.5 / 180.0 * pi},\n >>> \"accelerometer\": {\n >>> \"noise_density\": 2.0 * 2.0e-3,\n >>> \"random_walk\": 2.0 * 3.0e-3,\n >>> \"bias_correlation_time\": 300.0,\n >>> \"turn_on_bias_sigma\": 20.0e-3 * 9.8\n >>> },\n >>> \"update_rate\": 1.0} # Hz\n \"\"\"\n\n # Initialize the Super class \"object\" attributes\n super().__init__(sensor_type=\"IMU\", update_rate=config.get(\"update_rate\", 250.0))\n\n # Orientation noise constant\n self._orientation_noise: float = 0.0\n\n # Gyroscope noise constants\n self._gyroscope_bias: np.ndarray = np.zeros((3,))\n gyroscope_config = config.get(\"gyroscope\", {})\n self._gyroscope_noise_density = gyroscope_config.get(\"noise_density\", 0.0003393695767766752)\n self._gyroscope_random_walk = gyroscope_config.get(\"random_walk\", 3.878509448876288E-05)\n self._gyroscope_bias_correlation_time = gyroscope_config.get(\"bias_correlation_time\", 1.0E3)\n self._gyroscope_turn_on_bias_sigma = gyroscope_config.get(\"turn_on_bias_sigma\", 0.008726646259971648)\n\n # Accelerometer noise constants\n self._accelerometer_bias: np.ndarray = np.zeros((3,))\n accelerometer_config = config.get(\"accelerometer\", {})\n self._accelerometer_noise_density = accelerometer_config.get(\"noise_density\", 0.004)\n self._accelerometer_random_walk = accelerometer_config.get(\"random_walk\", 0.006)\n self._accelerometer_bias_correlation_time = accelerometer_config.get(\"bias_correlation_time\", 300.0)\n self._accelerometer_turn_on_bias_sigma = accelerometer_config.get(\"turn_on_bias_sigma\", 0.196)\n\n # Auxiliar variable used to compute the linear acceleration of the vehicle\n self._prev_linear_velocity = np.zeros((3,))\n\n # Save the current state measured by the IMU\n self._state = {\n \"orientation\": np.array([1.0, 0.0, 0.0, 0.0]),\n \"angular_velocity\": np.array([0.0, 0.0, 0.0]),\n \"linear_acceleration\": np.array([0.0, 0.0, 0.0]),\n }\n\n @property\n def state(self):\n \"\"\"\n (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time\n \"\"\"\n return self._state\n\n @Sensor.update_at_rate\n def update(self, state: State, dt: float):\n \"\"\"Method that implements the logic of an IMU. In this method we start by generating the random walk of the \n gyroscope. This value is then added to the real angular velocity of the vehicle (FLU relative to ENU inertial frame\n expressed in FLU body frame). The same logic is followed for the accelerometer and the accelerations. After this step,\n the angular velocity is rotated such that it expressed a FRD body frame, relative to a NED inertial frame, expressed\n in the FRD body frame. Additionally, the acceleration is also rotated, such that it becomes expressed in the body\n FRD frame of the vehicle. This sensor outputs data that follows the PX4 adopted standard.\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n (dict) A dictionary containing the current state of the sensor (the data produced by the sensor)\n \"\"\"\n\n # Gyroscopic terms\n tau_g: float = self._accelerometer_bias_correlation_time\n\n # Discrete-time standard deviation equivalent to an \"integrating\" sampler with integration time dt\n sigma_g_d: float = 1 / np.sqrt(dt) * self._gyroscope_noise_density\n sigma_b_g: float = self._gyroscope_random_walk\n\n # Compute exact covariance of the process after dt [Maybeck 4-114]\n sigma_b_g_d: float = np.sqrt(-sigma_b_g * sigma_b_g * tau_g / 2.0 * (np.exp(-2.0 * dt / tau_g) - 1.0))\n\n # Compute state-transition\n phi_g_d: float = np.exp(-1.0 / tau_g * dt)\n\n # Simulate gyroscope noise processes and add them to the true angular rate.\n angular_velocity: np.ndarray = np.zeros((3,))\n\n for i in range(3):\n self._gyroscope_bias[i] = phi_g_d * self._gyroscope_bias[i] + sigma_b_g_d * np.random.randn()\n angular_velocity[i] = state.angular_velocity[i] + sigma_g_d * np.random.randn() + self._gyroscope_bias[i]\n\n # Accelerometer terms\n tau_a: float = self._accelerometer_bias_correlation_time\n\n # Discrete-time standard deviation equivalent to an \"integrating\" sampler with integration time dt\n sigma_a_d: float = 1.0 / np.sqrt(dt) * self._accelerometer_noise_density\n sigma_b_a: float = self._accelerometer_random_walk\n\n # Compute exact covariance of the process after dt [Maybeck 4-114].\n sigma_b_a_d: float = np.sqrt(-sigma_b_a * sigma_b_a * tau_a / 2.0 * (np.exp(-2.0 * dt / tau_a) - 1.0))\n\n # Compute state-transition.\n phi_a_d: float = np.exp(-1.0 / tau_a * dt)\n\n # Compute the linear acceleration from diferentiating the velocity of the vehicle expressed in the inertial frame\n linear_acceleration_inertial = (state.linear_velocity - self._prev_linear_velocity) / dt\n linear_acceleration_inertial = linear_acceleration_inertial - GRAVITY_VECTOR\n\n # Update the previous linear velocity for the next computation\n self._prev_linear_velocity = state.linear_velocity\n\n # Compute the linear acceleration of the body frame, with respect to the inertial frame, expressed in the body frame\n linear_acceleration = np.array(Rotation.from_quat(state.attitude).inv().apply(linear_acceleration_inertial))\n\n # Simulate the accelerometer noise processes and add them to the true linear aceleration values\n for i in range(3):\n self._accelerometer_bias[i] = phi_a_d * self._accelerometer_bias[i] + sigma_b_a_d * np.random.rand()\n linear_acceleration[i] = (\n linear_acceleration[i] + sigma_a_d * np.random.randn()\n ) #+ self._accelerometer_bias[i]\n\n # TODO - Add small \"noisy\" to the attitude\n\n # --------------------------------------------------------------------------------------------\n # Apply rotations such that we express the IMU data according to the FRD body frame convention\n # --------------------------------------------------------------------------------------------\n\n # Convert the orientation to the FRD-NED standard\n attitude_flu_enu = Rotation.from_quat(state.attitude)\n attitude_frd_enu = attitude_flu_enu * rot_FLU_to_FRD\n attitude_frd_ned = rot_ENU_to_NED * attitude_frd_enu\n\n # Convert the angular velocity from FLU to FRD standard\n angular_velocity_frd = rot_FLU_to_FRD.apply(angular_velocity)\n\n # Convert the linear acceleration in the body frame from FLU to FRD standard\n linear_acceleration_frd = rot_FLU_to_FRD.apply(linear_acceleration)\n\n # Add the values to the dictionary and return it\n self._state = {\n \"orientation\": attitude_frd_ned.as_quat(),\n \"angular_velocity\": angular_velocity_frd,\n \"linear_acceleration\": linear_acceleration_frd,\n }\n\n return self._state\n"},"size":{"kind":"number","value":8652,"string":"8,652"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":48.44571400888164,"string":"48.445714"},"max_line_length":{"kind":"number","value":167,"string":"167"},"alphanum_fraction":{"kind":"number","value":0.6249422098214352,"string":"0.624942"}}},{"rowIdx":75,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/interface/pegasus_interface.py"},"content":{"kind":"string","value":"\"\"\"\n| File: pegasus_interface.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of the PegasusInterface class (a singleton) that is used to manage the Pegasus framework.\n\"\"\"\n\n__all__ = [\"PegasusInterface\"]\n\n# Importing Lock in ordef to have a multithread safe Pegasus singleton that manages the entire Pegasus extension\nimport gc\nimport yaml\nimport asyncio\nimport os\nfrom threading import Lock\n\n# NVidia API imports\nimport carb\nimport omni.kit.app\nfrom omni.isaac.core.world import World\nfrom omni.isaac.core.utils.stage import clear_stage, create_new_stage_async, update_stage_async\nfrom omni.isaac.core.utils.viewports import set_camera_view\nimport omni.isaac.core.utils.nucleus as nucleus\n\n# Pegasus Simulator internal API\nfrom pegasus.simulator.params import DEFAULT_WORLD_SETTINGS, SIMULATION_ENVIRONMENTS, CONFIG_FILE\nfrom pegasus.simulator.logic.vehicle_manager import VehicleManager\n\n\nclass PegasusInterface:\n \"\"\"\n PegasusInterface is a singleton class (there is only one object instance at any given time) that will be used\n to \n \"\"\"\n\n # The object instance of the Vehicle Manager\n _instance = None\n _is_initialized = False\n\n # Lock for safe multi-threading\n _lock: Lock = Lock()\n\n def __init__(self):\n \"\"\"\n Initialize the PegasusInterface singleton object (only runs once at a time)\n \"\"\"\n\n # If we already have an instance of the PegasusInterface, do not overwrite it!\n if PegasusInterface._is_initialized:\n return\n\n carb.log_info(\"Initializing the Pegasus Simulator Extension\")\n PegasusInterface._is_initialized = True\n\n # Get a handle to the vehicle manager instance which will manage which vehicles are spawned in the world\n # to be controlled and simulated\n self._vehicle_manager = VehicleManager()\n\n # Initialize the world with the default simulation settings\n self._world_settings = DEFAULT_WORLD_SETTINGS\n self._world = None\n #self.initialize_world()\n\n # Initialize the latitude, longitude and altitude of the simulated environment at the (0.0, 0.0, 0.0) coordinate\n # from the extension configuration file\n self._latitude, self._longitude, self._altitude = self._get_global_coordinates_from_config()\n\n # Get the px4_path from the extension configuration file\n self._px4_path: str = self._get_px4_path_from_config()\n self._px4_default_airframe: str = self._get_px4_default_airframe_from_config()\n carb.log_info(\"Default PX4 path:\" + str(self._px4_path))\n\n @property\n def world(self):\n \"\"\"The current omni.isaac.core.world World instance\n\n Returns:\n omni.isaac.core.world: The world instance\n \"\"\"\n return self._world\n\n @property\n def vehicle_manager(self):\n \"\"\"The instance of the VehicleManager.\n\n Returns:\n VehicleManager: The current instance of the VehicleManager.\n \"\"\"\n return self._vehicle_manager\n \n @property\n def latitude(self):\n \"\"\"The latitude of the origin of the simulated world in degrees.\n\n Returns:\n float: The latitude of the origin of the simulated world in degrees.\n \"\"\"\n return self._latitude\n \n @property\n def longitude(self):\n \"\"\"The longitude of the origin of the simulated world in degrees.\n\n Returns:\n float: The longitude of the origin of the simulated world in degrees.\n \"\"\"\n return self._longitude\n \n @property\n def altitude(self):\n \"\"\"The altitude of the origin of the simulated world in meters.\n\n Returns:\n float: The latitude of the origin of the simulated world in meters.\n \"\"\"\n return self._altitude\n \n @property\n def px4_path(self):\n \"\"\"A string with the installation directory for PX4 (if it was setup). Otherwise it is None.\n\n Returns:\n str: A string with the installation directory for PX4 (if it was setup). Otherwise it is None.\n \"\"\"\n return self._px4_path\n \n @property\n def px4_default_airframe(self):\n \"\"\"A string with the PX4 default airframe (if it was setup). Otherwise it is None.\n\n Returns:\n str: A string with the PX4 default airframe (if it was setup). Otherwise it is None.\n \"\"\"\n return self._px4_default_airframe\n \n def set_global_coordinates(self, latitude=None, longitude=None, altitude=None):\n \"\"\"Method that can be used to set the latitude, longitude and altitude of the simulation world at the origin.\n\n Args:\n latitude (float): The latitude of the origin of the simulated world in degrees. Defaults to None.\n longitude (float): The longitude of the origin of the simulated world in degrees. Defaults to None.\n altitude (float): The altitude of the origin of the simulated world in meters. Defaults to None.\n \"\"\"\n\n if latitude is not None:\n self._latitude = latitude\n\n if longitude is not None:\n self._longitude = longitude\n\n if self.altitude is not None:\n self._altitude = altitude\n\n carb.log_warn(\"New global coordinates set to: \" + str(self._latitude) + \", \" + str(self._longitude) + \", \" + str(self._altitude))\n\n def initialize_world(self):\n \"\"\"Method that initializes the world object\n \"\"\"\n self._world = World(**self._world_settings)\n #asyncio.ensure_future(self._world.initialize_simulation_context_async())\n\n def get_vehicle(self, stage_prefix: str):\n \"\"\"Method that returns the vehicle object given its 'stage_prefix', i.e., the name the vehicle was spawned with in the simulator.\n\n Args:\n stage_prefix (str): The name the vehicle will present in the simulator when spawned. \n\n Returns:\n Vehicle: Returns a vehicle object that was spawned with the given 'stage_prefix'\n \"\"\"\n return self._vehicle_manager.vehicles[stage_prefix]\n\n def get_all_vehicles(self):\n \"\"\"\n Method that returns a list of vehicles that are considered active in the simulator\n\n Returns:\n list: A list of all vehicles that are currently instantiated.\n \"\"\"\n return self._vehicle_manager.vehicles\n\n def get_default_environments(self):\n \"\"\"\n Method that returns a dictionary containing all the default simulation environments and their path\n \"\"\"\n return SIMULATION_ENVIRONMENTS\n\n def generate_quadrotor_config_from_yaml(self, file: str):\n \"\"\"_summary_\n\n Args:\n file (str): _description_\n\n Returns:\n _type_: _description_\n \"\"\"\n\n # Load the quadrotor configuration data from the given yaml file\n with open(file) as f:\n data = yaml.safe_load(f)\n\n return self.generate_quadrotor_config_from_dict(data)\n\n def clear_scene(self):\n \"\"\"\n Method that when invoked will clear all vehicles and the simulation environment, leaving only an empty world with a physics environment.\n \"\"\"\n\n # If the physics simulation was running, stop it first\n if self.world is not None:\n self.world.stop()\n\n # Clear the world\n if self.world is not None:\n self.world.clear_all_callbacks()\n self.world.clear()\n\n # Clear the stage\n clear_stage()\n\n # Remove all the robots that were spawned\n self._vehicle_manager.remove_all_vehicles()\n\n # Call python's garbage collection\n gc.collect()\n\n # Re-initialize the physics context\n asyncio.ensure_future(self._world.initialize_simulation_context_async())\n carb.log_info(\"Current scene and its vehicles has been deleted\")\n\n async def load_environment_async(self, usd_path: str, force_clear: bool=False):\n \"\"\"Method that loads a given world (specified in the usd_path) into the simulator asynchronously.\n\n Args:\n usd_path (str): The path where the USD file describing the world is located.\n force_clear (bool): Whether to perform a clear before loading the asset. Defaults to False. \n It should be set to True only if the method is invoked from an App (GUI mode).\n \"\"\"\n\n # Reset and pause the world simulation (only if force_clear is true)\n # This is done to maximize the support between running in GUI as extension vs App\n if force_clear == True:\n\n # Create a new stage and initialize (or re-initialized) the world\n await create_new_stage_async()\n self._world = World(**self._world_settings)\n await self._world.initialize_simulation_context_async()\n self._world = World.instance()\n\n await self.world.reset_async()\n await self.world.stop_async()\n\n # Load the USD asset that will be used for the environment\n try:\n self.load_asset(usd_path, \"/World/layout\")\n except Exception as e:\n carb.log_warn(\"Could not load the desired environment: \" + str(e))\n\n carb.log_info(\"A new environment has been loaded successfully\")\n\n def load_environment(self, usd_path: str, force_clear: bool=False):\n \"\"\"Method that loads a given world (specified in the usd_path) into the simulator. If invoked from a python app,\n this method should have force_clear=False, as the world reset and stop are performed asynchronously by this method, \n and when we are operating in App mode, we want everything to run in sync.\n\n Args:\n usd_path (str): The path where the USD file describing the world is located.\n force_clear (bool): Whether to perform a clear before loading the asset. Defaults to False.\n \"\"\"\n asyncio.ensure_future(self.load_environment_async(usd_path, force_clear))\n\n def load_nvidia_environment(self, environment_asset: str = \"Hospital/hospital.usd\"):\n \"\"\"\n Method that is used to load NVidia internally provided USD stages into the simulaton World\n\n Args:\n environment_asset (str): The name of the nvidia asset inside the /Isaac/Environments folder. Default to Hospital/hospital.usd.\n \"\"\"\n\n # Get the nvidia assets root path\n nvidia_assets_path = nucleus.get_assets_root_path()\n\n # Define the environments path inside the NVidia assets\n environments_path = \"/Isaac/Environments\"\n\n # Get the complete usd path\n usd_path = nvidia_assets_path + environments_path + \"/\" + environment_asset\n\n # Try to load the asset into the world\n self.load_asset(usd_path, \"/World/layout\")\n\n def load_asset(self, usd_asset: str, stage_prefix: str):\n \"\"\"\n Method that will attempt to load an asset into the current simulation world, given the USD asset path.\n\n Args:\n usd_asset (str): The path where the USD file describing the world is located.\n stage_prefix (str): The name the vehicle will present in the simulator when spawned. \n \"\"\"\n\n # Try to check if there is already a prim with the same stage prefix in the stage\n if self._world.stage.GetPrimAtPath(stage_prefix):\n raise Exception(\"A primitive already exists at the specified path\")\n\n # Create the stage primitive and load the usd into it\n prim = self._world.stage.DefinePrim(stage_prefix)\n success = prim.GetReferences().AddReference(usd_asset)\n\n if not success:\n raise Exception(\"The usd asset\" + usd_asset + \"is not load at stage path \" + stage_prefix)\n\n def set_viewport_camera(self, camera_position, camera_target):\n \"\"\"Sets the viewport camera to given position and makes it point to another target position.\n\n Args:\n camera_position (list): A list with [X, Y, Z] coordinates of the camera in ENU inertial frame.\n camera_target (list): A list with [X, Y, Z] coordinates of the target that the camera should point to in the ENU inertial frame.\n \"\"\"\n # Set the camera view to a fixed value\n set_camera_view(eye=camera_position, target=camera_target)\n\n def set_world_settings(self, physics_dt=None, stage_units_in_meters=None, rendering_dt=None):\n \"\"\"\n Set the current world settings to the pre-defined settings. TODO - finish the implementation of this method.\n For now these new setting will never override the default ones.\n \"\"\"\n\n # Set the physics engine update rate\n if physics_dt is not None:\n self._world_settings[\"physics_dt\"] = physics_dt\n\n # Set the units of the simulator to meters\n if stage_units_in_meters is not None:\n self._world_settings[\"stage_units_in_meters\"] = stage_units_in_meters\n\n # Set the render engine update rate (might not be the same as the physics engine)\n if rendering_dt is not None:\n self._world_settings[\"rendering_dt\"] = rendering_dt\n\n def _get_px4_path_from_config(self):\n \"\"\"\n Method that reads the configured PX4 installation directory from the extension configuration file \n\n Returns:\n str: A string with the path to the px4 configuration directory or empty string ''\n \"\"\"\n\n px4_dir = \"\"\n \n # Open the configuration file. If it fails, just return the empty path\n try:\n with open(CONFIG_FILE, 'r') as f:\n data = yaml.safe_load(f)\n px4_dir = os.path.expanduser(data.get(\"px4_dir\", None))\n except:\n carb.log_warn(\"Could not retrieve px4_dir from: \" + str(CONFIG_FILE))\n\n return px4_dir\n \n def _get_px4_default_airframe_from_config(self):\n \"\"\"\n Method that reads the configured PX4 default airframe from the extension configuration file \n\n Returns:\n str: A string with the path to the PX4 default airframe or empty string ''\n \"\"\"\n px4_default_airframe = \"\"\n \n # Open the configuration file. If it fails, just return the empty path\n try:\n with open(CONFIG_FILE, 'r') as f:\n data = yaml.safe_load(f)\n px4_default_airframe = os.path.expanduser(data.get(\"px4_default_airframe\", None))\n except:\n carb.log_warn(\"Could not retrieve px4_default_airframe from: \" + str(CONFIG_FILE))\n\n return px4_default_airframe\n\n\n def _get_global_coordinates_from_config(self):\n \"\"\"Method that reads the default latitude, longitude and altitude from the extension configuration file\n\n Returns:\n (float, float, float): A tuple of 3 floats with the latitude, longitude and altitude to use as the origin of the world\n \"\"\"\n\n latitude = 0.0\n longitude = 0.0\n altitude = 0.0\n\n # Open the configuration file. If it fails, just return the empty path\n try:\n with open(CONFIG_FILE, 'r') as f:\n data = yaml.safe_load(f)\n \n # Try to read the coordinates from the configuration file\n global_coordinates = data.get(\"global_coordinates\", {})\n latitude = global_coordinates.get(\"latitude\", 0.0)\n longitude = global_coordinates.get(\"longitude\", 0.0)\n altitude = global_coordinates.get(\"altitude\", 0.0)\n except:\n carb.log_warn(\"Could not retrieve the global coordinates from: \" + str(CONFIG_FILE))\n\n return (latitude, longitude, altitude)\n\n def set_px4_path(self, path: str):\n \"\"\"Method that allows a user to save a new px4 directory in the configuration files of the extension.\n\n Args:\n absolute_path (str): The new path of the px4-autopilot installation directory\n \"\"\"\n \n # Save the new path for current use during this simulation\n self._px4_path = os.path.expanduser(path)\n\n # Save the new path in the configurations file for the next simulations\n try:\n\n # Open the configuration file and the all the configurations that it contains\n with open(CONFIG_FILE, 'r') as f:\n data = yaml.safe_load(f)\n\n # Open the configuration file. If it fails, just warn in the console\n with open(CONFIG_FILE, 'w') as f:\n data[\"px4_dir\"] = path\n yaml.dump(data, f)\n except:\n carb.log_warn(\"Could not save px4_dir to: \" + str(CONFIG_FILE))\n\n carb.log_warn(\"New px4_dir set to: \" + str(self._px4_path))\n\n def set_px4_default_airframe(self, airframe: str):\n \"\"\"Method that allows a user to save a new px4 default airframe for the extension.\n\n Args:\n absolute_path (str): The new px4 default airframe\n \"\"\"\n \n # Save the new path for current use during this simulation\n self._px4_default_airframe = airframe\n\n # Save the new path in the configurations file for the next simulations\n try:\n\n # Open the configuration file and the all the configurations that it contains\n with open(CONFIG_FILE, 'r') as f:\n data = yaml.safe_load(f)\n\n # Open the configuration file. If it fails, just warn in the console\n with open(CONFIG_FILE, 'w') as f:\n data[\"px4_default_airframe\"] = airframe\n yaml.dump(data, f)\n except:\n carb.log_warn(\"Could not save px4_default_airframe to: \" + str(CONFIG_FILE))\n\n carb.log_warn(\"New px4_default_airframe set to: \" + str(self._px4_default_airframe))\n\n def set_default_global_coordinates(self):\n \"\"\"\n Method that sets the latitude, longitude and altitude from the pegasus interface to the \n default global coordinates specified in the extension configuration file\n \"\"\"\n self._latitude, self._longitude, self._altitude = self._get_global_coordinates_from_config()\n\n def set_new_default_global_coordinates(self, latitude: float=None, longitude: float=None, altitude: float=None):\n \n # Set the current global coordinates to the new default global coordinates\n self.set_global_coordinates(latitude, longitude, altitude)\n\n # Update the default global coordinates in the configuration file\n try:\n # Open the configuration file and the all the configurations that it contains\n with open(CONFIG_FILE, 'r') as f:\n data = yaml.safe_load(f)\n\n # Open the configuration file. If it fails, just warn in the console\n with open(CONFIG_FILE, 'w') as f:\n\n if latitude is not None:\n data[\"global_coordinates\"][\"latitude\"] = latitude\n\n if longitude is not None:\n data[\"global_coordinates\"][\"longitude\"] = longitude\n\n if altitude is not None:\n data[\"global_coordinates\"][\"altitude\"] = altitude\n \n # Save the updated configurations \n yaml.dump(data, f)\n except:\n carb.log_warn(\"Could not save the new global coordinates to: \" + str(CONFIG_FILE))\n\n carb.log_warn(\"New global coordinates set to: latitude=\" + str(latitude) + \", longitude=\" + str(longitude) + \", altitude=\" + str(altitude))\n\n\n def __new__(cls):\n \"\"\"Allocates the memory and creates the actual PegasusInterface object is not instance exists yet. Otherwise,\n returns the existing instance of the PegasusInterface class.\n\n Returns:\n VehicleManger: the single instance of the VehicleManager class\n \"\"\"\n\n # Use a lock in here to make sure we do not have a race condition\n # when using multi-threading and creating the first instance of the Pegasus extension manager\n with cls._lock:\n if cls._instance is None:\n cls._instance = object.__new__(cls)\n\n return PegasusInterface._instance\n\n def __del__(self):\n \"\"\"Destructor for the object. Destroys the only existing instance of this class.\"\"\"\n PegasusInterface._instance = None\n PegasusInterface._is_initialized = False"},"size":{"kind":"number","value":20371,"string":"20,371"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":38.55728147852955,"string":"38.557281"},"max_line_length":{"kind":"number","value":147,"string":"147"},"alphanum_fraction":{"kind":"number","value":0.6350203720664169,"string":"0.63502"}}},{"rowIdx":76,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/backend.py"},"content":{"kind":"string","value":"\"\"\"\n| File: backend.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Description:\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n\nclass Backend:\n \"\"\"\n This class defines the templates for the communication and control backend. Every vehicle can have at least one backend\n at the same time. Every timestep, the methods 'update_state' and 'update_sensor' are called to update the data produced\n by the simulation, i.e. for every time step the backend will receive teh current state of the vehicle and its sensors. \n Additionally, the backend must provide a method named 'input_reference' which will be used by the vehicle simulation\n to know the desired angular velocities to apply to the rotors of the vehicle. The method 'update' is called on every\n physics step and can be use to implement some logic or send data to another interface (such as PX4 through mavlink or ROS2).\n The methods 'start', 'stop' and 'reset' are callbacks that get called when the simulation is started, stoped and reset as the name implies.\n \"\"\"\n\n def __init__(self):\n \"\"\"Initialize the Backend class\n \"\"\"\n self._vehicle = None\n\n \"\"\"\n Properties\n \"\"\"\n @property\n def vehicle(self):\n \"\"\"A reference to the vehicle associated with this backend.\n\n Returns:\n Vehicle: A reference to the vehicle associated with this backend.\n \"\"\"\n return self._vehicle\n\n def initialize(self, vehicle):\n \"\"\"A method that can be invoked when the simulation is starting to give access to the control backend \n to the entire vehicle object. Even though we provide update_sensor and update_state callbacks that are called\n at every physics step with the latest vehicle state and its sensor data, having access to the full vehicle\n object may prove usefull under some circumstances. This is nice to give users the possibility of overiding\n default vehicle behaviour via this control backend structure.\n\n Args:\n vehicle (Vehicle): A reference to the vehicle that this sensor is associated with\n \"\"\"\n self._vehicle = vehicle\n\n def update_sensor(self, sensor_type: str, data):\n \"\"\"Method that when implemented, should handle the receival of sensor data\n\n Args:\n sensor_type (str): A name that describes the type of sensor\n data (dict): A dictionary that contains the data produced by the sensor\n \"\"\"\n pass\n\n def update_state(self, state):\n \"\"\"Method that when implemented, should handle the receival of the state of the vehicle using this callback\n\n Args:\n state (State): The current state of the vehicle.\n \"\"\"\n pass\n\n def input_reference(self):\n \"\"\"Method that when implemented, should return a list of desired angular velocities to apply to the vehicle rotors\n \"\"\"\n return []\n\n def update(self, dt: float):\n \"\"\"Method that when implemented, should be used to update the state of the backend and the information being sent/received\n from the communication interface. This method will be called by the simulation on every physics step\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n pass\n\n def start(self):\n \"\"\"Method that when implemented should handle the begining of the simulation of vehicle\n \"\"\"\n pass\n\n def stop(self):\n \"\"\"Method that when implemented should handle the stopping of the simulation of vehicle\n \"\"\"\n pass\n\n def reset(self):\n \"\"\"Method that when implemented, should handle the reset of the vehicle simulation to its original state\n \"\"\"\n pass\n"},"size":{"kind":"number","value":3830,"string":"3,830"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":40.19354795490809,"string":"40.193548"},"max_line_length":{"kind":"number","value":143,"string":"143"},"alphanum_fraction":{"kind":"number","value":0.6749347256723408,"string":"0.674935"}}},{"rowIdx":77,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/__init__.py"},"content":{"kind":"string","value":"\"\"\"\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n\nfrom .backend import Backend\nfrom .mavlink_backend import MavlinkBackend, MavlinkBackendConfig\nfrom .ros2_backend import ROS2Backend\n"},"size":{"kind":"number","value":288,"string":"288"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":31.111107654321373,"string":"31.111108"},"max_line_length":{"kind":"number","value":82,"string":"82"},"alphanum_fraction":{"kind":"number","value":0.7847222194974923,"string":"0.784722"}}},{"rowIdx":78,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/ros2_backend.py"},"content":{"kind":"string","value":"\"\"\"\n| File: ros2_backend.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Description: File that implements the ROS2 Backend for communication/control with/of the vehicle simulation through ROS2 topics\n| License: BSD-3-Clause. Copyright (c) 2024, Marcelo Jacinto. All rights reserved.\n\"\"\"\nimport carb\nfrom omni.isaac.core.utils.extensions import disable_extension, enable_extension\n\n# Perform some checks, because Isaac Sim some times does not play nice when using ROS/ROS2\ndisable_extension(\"omni.isaac.ros_bridge\")\nenable_extension(\"omni.isaac.ros2_bridge\")\n\n# ROS2 imports\nimport rclpy\nfrom std_msgs.msg import Float64\nfrom geometry_msgs.msg import TransformStamped\nfrom sensor_msgs.msg import Imu, MagneticField, NavSatFix, NavSatStatus\nfrom geometry_msgs.msg import PoseStamped, TwistStamped, AccelStamped\n\n# TF imports\nfrom tf2_ros.static_transform_broadcaster import StaticTransformBroadcaster\nfrom tf2_ros.transform_broadcaster import TransformBroadcaster\n\nfrom pegasus.simulator.logic.backends.backend import Backend\n\nclass ROS2Backend(Backend):\n\n def __init__(self, vehicle_id: int, num_rotors=4, config: dict = {}):\n \"\"\"Initialize the ROS2 Camera class\n\n Args:\n camera_prim_path (str): Path to the camera prim. Global path when it starts with `/`, else local to vehicle prim path\n config (dict): A Dictionary that contains all the parameters for configuring the ROS2Camera - it can be empty or only have some of the parameters used by the ROS2Camera.\n\n Examples:\n The dictionary default parameters are\n\n >>> {\"namespace\": \"drone\" # Namespace to append to the topics\n >>> \"pub_pose\": True, # Publish the pose of the vehicle\n >>> \"pub_twist\": True, # Publish the twist of the vehicle\n >>> \"pub_twist_inertial\": True, # Publish the twist of the vehicle in the inertial frame\n >>> \"pub_accel\": True, # Publish the acceleration of the vehicle\n >>> \"pub_imu\": True, # Publish the IMU data\n >>> \"pub_mag\": True, # Publish the magnetometer data\n >>> \"pub_gps\": True, # Publish the GPS data\n >>> \"pub_gps_vel\": True, # Publish the GPS velocity data\n >>> \"pose_topic\": \"state/pose\", # Position and attitude of the vehicle in ENU\n >>> \"twist_topic\": \"state/twist\", # Linear and angular velocities in the body frame of the vehicle\n >>> \"twist_inertial_topic\": \"state/twist_inertial\" # Linear velocity of the vehicle in the inertial frame\n >>> \"accel_topic\": \"state/accel\", # Linear acceleration of the vehicle in the inertial frame\n >>> \"imu_topic\": \"sensors/imu\", # IMU data\n >>> \"mag_topic\": \"sensors/mag\", # Magnetometer data\n >>> \"gps_topic\": \"sensors/gps\", # GPS data\n >>> \"gps_vel_topic\": \"sensors/gps_twist\", # GPS velocity data\n \"\"\"\n\n # Save the configurations for this backend\n self._id = vehicle_id\n self._num_rotors = num_rotors\n\n self._namespace = config.get(\"namespace\", \"drone\" + str(vehicle_id))\n\n # Start the actual ROS2 setup here\n rclpy.init()\n self.node = rclpy.create_node(\"vehicle_\" + str(vehicle_id))\n\n # Create publishers for the state of the vehicle in ENU\n if config.get(\"pub_pose\", True):\n self.pose_pub = self.node.create_publisher(PoseStamped, self._namespace + str(self._id) + \"/\" + config.get(\"pose_topic\", \"state/pose\"), rclpy.qos.qos_profile_sensor_data)\n \n if config.get(\"pub_twist\", True):\n self.twist_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + \"/\" + config.get(\"twist_topic\", \"state/twist\"), rclpy.qos.qos_profile_sensor_data)\n\n if config.get(\"pub_twist_inertial\", True):\n self.twist_inertial_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + \"/\" + config.get(\"twist_inertial_topic\", \"state/twist_inertial\"), rclpy.qos.qos_profile_sensor_data)\n\n if config.get(\"pub_accel\", True):\n self.accel_pub = self.node.create_publisher(AccelStamped, self._namespace + str(self._id) + \"/\" + config.get(\"accel_topic\", \"state/accel\"), rclpy.qos.qos_profile_sensor_data)\n\n # Create publishers for some sensor data\n if config.get(\"pub_imu\", True):\n self.imu_pub = self.node.create_publisher(Imu, self._namespace + str(self._id) + \"/\" + config.get(\"imu_topic\", \"sensors/imu\"), rclpy.qos.qos_profile_sensor_data)\n \n if config.get(\"pub_mag\", True):\n self.mag_pub = self.node.create_publisher(MagneticField, self._namespace + str(self._id) + \"/\" + config.get(\"mag_topic\", \"sensors/mag\"), rclpy.qos.qos_profile_sensor_data)\n\n if config.get(\"pub_gps\", True):\n self.gps_pub = self.node.create_publisher(NavSatFix, self._namespace + str(self._id) + \"/\" + config.get(\"gps_topic\", \"sensors/gps\"), rclpy.qos.qos_profile_sensor_data)\n \n if config.get(\"pub_gps_vel\", True):\n self.gps_vel_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + \"/\" + config.get(\"gps_vel_topic\", \"sensors/gps_twist\"), rclpy.qos.qos_profile_sensor_data)\n \n # Subscribe to vector of floats with the target angular velocities to control the vehicle\n # This is not ideal, but we need to reach out to NVIDIA so that they can improve the ROS2 support with custom messages\n # The current setup as it is.... its a pain!!!!\n self.rotor_subs = []\n for i in range(self._num_rotors):\n self.rotor_subs.append(self.node.create_subscription(Float64, self._namespace + str(self._id) + \"/control/rotor\" + str(i) + \"/ref\", lambda x: self.rotor_callback(x, i),10))\n \n # Setup zero input reference for the thrusters\n self.input_ref = [0.0 for i in range(self._num_rotors)]\n\n # Initiliaze the static tf broadcaster for the sensors\n self.tf_static_broadcaster = StaticTransformBroadcaster(self.node)\n\n # Initialize the static tf broadcaster for the base_link transformation\n self.send_static_transforms()\n\n # Initialize the dynamic tf broadcaster for the position of the body of the vehicle (base_link) with respect to the inertial frame (map - ENU) expressed in the inertil frame (map - ENU)\n self.tf_broadcaster = TransformBroadcaster(self.node)\n\n def send_static_transforms(self):\n\n # Create the transformation from base_link FLU (ROS standard) to base_link FRD (standard in airborn and marine vehicles)\n t = TransformStamped()\n t.header.stamp = self.node.get_clock().now().to_msg()\n t.header.frame_id = self._namespace + '_' + 'base_link'\n t.child_frame_id = self._namespace + '_' + 'base_link_frd'\n\n # Converts from FLU to FRD\n t.transform.translation.x = 0.0\n t.transform.translation.y = 0.0\n t.transform.translation.z = 0.0\n t.transform.rotation.x = 1.0\n t.transform.rotation.y = 0.0\n t.transform.rotation.z = 0.0\n t.transform.rotation.w = 0.0\n\n self.tf_static_broadcaster.sendTransform(t)\n\n # Create the transform from map, i.e inertial frame (ROS standard) to map_ned (standard in airborn or marine vehicles)\n t = TransformStamped()\n t.header.stamp = self.node.get_clock().now().to_msg()\n t.header.frame_id = \"map\"\n t.child_frame_id = \"map_ned\"\n \n # Converts ENU to NED\n t.transform.translation.x = 0.0\n t.transform.translation.y = 0.0\n t.transform.translation.z = 0.0\n t.transform.rotation.x = -0.7071068\n t.transform.rotation.y = -0.7071068\n t.transform.rotation.z = 0.0\n t.transform.rotation.w = 0.0\n\n self.tf_static_broadcaster.sendTransform(t)\n\n def update_state(self, state):\n \"\"\"\n Method that when implemented, should handle the receivel of the state of the vehicle using this callback\n \"\"\"\n\n pose = PoseStamped()\n twist = TwistStamped()\n twist_inertial = TwistStamped()\n accel = AccelStamped()\n\n # Update the header\n pose.header.stamp = self.node.get_clock().now().to_msg()\n twist.header.stamp = pose.header.stamp\n twist_inertial.header.stamp = pose.header.stamp\n accel.header.stamp = pose.header.stamp\n\n pose.header.frame_id = \"map\"\n twist.header.frame_id = self._namespace + \"_\" + \"base_link\"\n twist_inertial.header.frame_id = \"map\"\n accel.header.frame_id = \"map\"\n\n # Fill the position and attitude of the vehicle in ENU\n pose.pose.position.x = state.position[0]\n pose.pose.position.y = state.position[1]\n pose.pose.position.z = state.position[2]\n\n pose.pose.orientation.x = state.attitude[0]\n pose.pose.orientation.y = state.attitude[1]\n pose.pose.orientation.z = state.attitude[2]\n pose.pose.orientation.w = state.attitude[3]\n\n # Fill the linear and angular velocities in the body frame of the vehicle\n twist.twist.linear.x = state.linear_body_velocity[0]\n twist.twist.linear.y = state.linear_body_velocity[1]\n twist.twist.linear.z = state.linear_body_velocity[2]\n\n twist.twist.angular.x = state.angular_velocity[0]\n twist.twist.angular.y = state.angular_velocity[1]\n twist.twist.angular.z = state.angular_velocity[2]\n\n # Fill the linear velocity of the vehicle in the inertial frame\n twist_inertial.twist.linear.x = state.linear_velocity[0]\n twist_inertial.twist.linear.y = state.linear_velocity[1]\n twist_inertial.twist.linear.z = state.linear_velocity[2]\n\n # Fill the linear acceleration in the inertial frame\n accel.accel.linear.x = state.linear_acceleration[0]\n accel.accel.linear.y = state.linear_acceleration[1]\n accel.accel.linear.z = state.linear_acceleration[2]\n\n # Publish the messages containing the state of the vehicle\n self.pose_pub.publish(pose)\n self.twist_pub.publish(twist)\n self.twist_inertial_pub.publish(twist_inertial)\n self.accel_pub.publish(accel)\n\n # Update the dynamic tf broadcaster with the current position of the vehicle in the inertial frame\n t = TransformStamped()\n t.header.stamp = pose.header.stamp\n t.header.frame_id = \"map\"\n t.child_frame_id = self._namespace + '_' + 'base_link'\n t.transform.translation.x = state.position[0]\n t.transform.translation.y = state.position[1]\n t.transform.translation.z = state.position[2]\n t.transform.rotation.x = state.attitude[0]\n t.transform.rotation.y = state.attitude[1]\n t.transform.rotation.z = state.attitude[2]\n t.transform.rotation.w = state.attitude[3]\n self.tf_broadcaster.sendTransform(t)\n \n\n def rotor_callback(self, ros_msg: Float64, rotor_id):\n # Update the reference for the rotor of the vehicle\n self.input_ref[rotor_id] = float(ros_msg.data)\n\n def update_sensor(self, sensor_type: str, data):\n \"\"\"\n Method that when implemented, should handle the receival of sensor data\n \"\"\"\n\n if sensor_type == \"IMU\":\n self.update_imu_data(data)\n elif sensor_type == \"GPS\":\n self.update_gps_data(data)\n elif sensor_type == \"Magnetometer\":\n self.update_mag_data(data)\n else:\n pass\n\n def update_imu_data(self, data):\n\n msg = Imu()\n\n # Update the header\n msg.header.stamp = self.node.get_clock().now().to_msg()\n msg.header.frame_id = self._namespace + '_' + \"base_link_frd\"\n \n # Update the angular velocity (NED + FRD)\n msg.angular_velocity.x = data[\"angular_velocity\"][0]\n msg.angular_velocity.y = data[\"angular_velocity\"][1]\n msg.angular_velocity.z = data[\"angular_velocity\"][2]\n \n # Update the linear acceleration (NED)\n msg.linear_acceleration.x = data[\"linear_acceleration\"][0]\n msg.linear_acceleration.y = data[\"linear_acceleration\"][1]\n msg.linear_acceleration.z = data[\"linear_acceleration\"][2]\n\n # Publish the message with the current imu state\n self.imu_pub.publish(msg)\n\n def update_gps_data(self, data):\n\n msg = NavSatFix()\n msg_vel = TwistStamped()\n\n # Update the headers\n msg.header.stamp = self.node.get_clock().now().to_msg()\n msg.header.frame_id = \"map_ned\"\n msg_vel.header.stamp = msg.header.stamp\n msg_vel.header.frame_id = msg.header.frame_id\n\n # Update the status of the GPS\n status_msg = NavSatStatus()\n status_msg.status = 0 # unaugmented fix position\n status_msg.service = 1 # GPS service\n msg.status = status_msg\n\n # Update the latitude, longitude and altitude\n msg.latitude = data[\"latitude\"]\n msg.longitude = data[\"longitude\"]\n msg.altitude = data[\"altitude\"]\n\n # Update the velocity of the vehicle measured by the GPS in the inertial frame (NED)\n msg_vel.twist.linear.x = data[\"velocity_north\"]\n msg_vel.twist.linear.y = data[\"velocity_east\"]\n msg_vel.twist.linear.z = data[\"velocity_down\"]\n\n # Publish the message with the current GPS state\n self.gps_pub.publish(msg)\n self.gps_vel_pub.publish(msg_vel)\n\n def update_mag_data(self, data):\n \n msg = MagneticField()\n\n # Update the headers\n msg.header.stamp = self.node.get_clock().now().to_msg()\n msg.header.frame_id = \"base_link_frd\"\n\n msg.magnetic_field.x = data[\"magnetic_field\"][0]\n msg.magnetic_field.y = data[\"magnetic_field\"][1]\n msg.magnetic_field.z = data[\"magnetic_field\"][2]\n\n # Publish the message with the current magnetic data\n self.mag_pub.publish(msg)\n\n def input_reference(self):\n \"\"\"\n Method that is used to return the latest target angular velocities to be applied to the vehicle\n\n Returns:\n A list with the target angular velocities for each individual rotor of the vehicle\n \"\"\"\n return self.input_ref\n\n def update(self, dt: float):\n \"\"\"\n Method that when implemented, should be used to update the state of the backend and the information being sent/received\n from the communication interface. This method will be called by the simulation on every physics step\n \"\"\"\n\n # In this case, do nothing as we are sending messages as soon as new data arrives from the sensors and state\n # and updating the reference for the thrusters as soon as receiving from ROS2 topics\n # Just poll for new ROS 2 messages in a non-blocking way\n rclpy.spin_once(self.node, timeout_sec=0)\n\n def start(self):\n \"\"\"\n Method that when implemented should handle the begining of the simulation of vehicle\n \"\"\"\n # Reset the reference for the thrusters\n self.input_ref = [0.0 for i in range(self._num_rotors)]\n\n def stop(self):\n \"\"\"\n Method that when implemented should handle the stopping of the simulation of vehicle\n \"\"\"\n # Reset the reference for the thrusters\n self.input_ref = [0.0 for i in range(self._num_rotors)]\n\n def reset(self):\n \"\"\"\n Method that when implemented, should handle the reset of the vehicle simulation to its original state\n \"\"\"\n # Reset the reference for the thrusters\n self.input_ref = [0.0 for i in range(self._num_rotors)]"},"size":{"kind":"number","value":15962,"string":"15,962"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":45.40406963545329,"string":"45.40407"},"max_line_length":{"kind":"number","value":213,"string":"213"},"alphanum_fraction":{"kind":"number","value":0.6262373135806141,"string":"0.626237"}}},{"rowIdx":79,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/mavlink_backend.py"},"content":{"kind":"string","value":"\"\"\"\n| File: mavlink_backend.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Description: File that implements the Mavlink Backend for communication/control with/of the vehicle simulation\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n__all__ = [\"MavlinkBackend\", \"MavlinkBackendConfig\"]\n\nimport carb\nimport time\nimport numpy as np\nfrom pymavlink import mavutil\n\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.backends.backend import Backend\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\nfrom pegasus.simulator.logic.backends.tools.px4_launch_tool import PX4LaunchTool\n\n\nclass SensorSource:\n \"\"\" The binary codes to signal which simulated data is being sent through mavlink\n\n Atribute:\n | ACCEL (int): mavlink binary code for the accelerometer (0b0000000000111 = 7)\n | GYRO (int): mavlink binary code for the gyroscope (0b0000000111000 = 56)\n | MAG (int): mavlink binary code for the magnetometer (0b0000111000000=448)\n | BARO (int): mavlink binary code for the barometer (0b1101000000000=6656)\n | DIFF_PRESS (int): mavlink binary code for the pressure sensor (0b0010000000000=1024)\n \"\"\"\n\n ACCEL: int = 7 \n GYRO: int = 56 \n MAG: int = 448 \n BARO: int = 6656\n DIFF_PRESS: int = 1024\n\n\nclass SensorMsg:\n \"\"\"\n An auxiliary data class where we write all the sensor data that is going to be sent through mavlink\n \"\"\"\n\n def __init__(self):\n\n # IMU Data\n self.new_imu_data: bool = False\n self.received_first_imu: bool = False\n self.xacc: float = 0.0\n self.yacc: float = 0.0\n self.zacc: float = 0.0\n self.xgyro: float = 0.0\n self.ygyro: float = 0.0\n self.zgyro: float = 0.0\n\n # Baro Data\n self.new_bar_data: bool = False\n self.abs_pressure: float = 0.0\n self.pressure_alt: float = 0.0\n self.temperature: float = 0.0\n\n # Magnetometer Data\n self.new_mag_data: bool = False\n self.xmag: float = 0.0\n self.ymag: float = 0.0\n self.zmag: float = 0.0\n\n # Airspeed Data\n self.new_press_data: bool = False\n self.diff_pressure: float = 0.0\n\n # GPS Data\n self.new_gps_data: bool = False\n self.fix_type: int = 0\n self.latitude_deg: float = -999\n self.longitude_deg: float = -999\n self.altitude: float = -999\n self.eph: float = 1.0\n self.epv: float = 1.0\n self.velocity: float = 0.0\n self.velocity_north: float = 0.0\n self.velocity_east: float = 0.0\n self.velocity_down: float = 0.0\n self.cog: float = 0.0\n self.satellites_visible: int = 0\n\n # Vision Pose\n self.new_vision_data: bool = False\n self.vision_x: float = 0.0\n self.vision_y: float = 0.0\n self.vision_z: float = 0.0\n self.vision_roll: float = 0.0\n self.vision_pitch: float = 0.0\n self.vision_yaw: float = 0.0\n self.vision_covariance = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\n\n # Simulation State\n self.new_sim_state: bool = False\n self.sim_attitude = [1.0, 0.0, 0.0, 0.0] # [w, x, y, z]\n self.sim_acceleration = [0.0, 0.0, 0.0] # [x,y,z body acceleration]\n self.sim_angular_vel = [0.0, 0.0, 0.0] # [roll-rate, pitch-rate, yaw-rate] rad/s\n self.sim_lat = 0.0 # [deg]\n self.sim_lon = 0.0 # [deg]\n self.sim_alt = 0.0 # [m]\n self.sim_ind_airspeed = 0.0 # Indicated air speed\n self.sim_true_airspeed = 0.0 # Indicated air speed\n self.sim_velocity_inertial = [0.0, 0.0, 0.0] # North-east-down [m/s]\n\n\nclass ThrusterControl:\n \"\"\"\n An auxiliary data class that saves the thrusters command data received via mavlink and \n scales them into individual angular velocities expressed in rad/s to apply to each rotor\n \"\"\"\n\n def __init__(\n self,\n num_rotors: int = 4,\n input_offset=[0, 0, 0, 0],\n input_scaling=[0, 0, 0, 0],\n zero_position_armed=[100, 100, 100, 100],\n ):\n \"\"\"Initialize the ThrusterControl object\n\n Args:\n num_rotors (int): The number of rotors that the actual system has 4.\n input_offset (list): A list with the offsets to apply to the rotor values received via mavlink. Defaults to [0, 0, 0, 0].\n input_scaling (list): A list with the scaling to apply to the rotor values received via mavlink. Defaults to [0, 0, 0, 0].\n zero_position_armed (list): Another list of offsets to apply to the rotor values received via mavlink. Defaults to [100, 100, 100, 100].\n \"\"\"\n\n self.num_rotors: int = num_rotors\n\n # Values to scale and offset the rotor control inputs received from PX4\n assert len(input_offset) == self.num_rotors\n self.input_offset = input_offset\n\n assert len(input_scaling) == self.num_rotors\n self.input_scaling = input_scaling\n\n assert len(zero_position_armed) == self.num_rotors\n self.zero_position_armed = zero_position_armed\n\n # The actual speed references to apply to the vehicle rotor joints\n self._input_reference = [0.0 for i in range(self.num_rotors)]\n\n @property\n def input_reference(self):\n \"\"\"A list of floats with the angular velocities in rad/s\n\n Returns:\n list: A list of floats with the angular velocities to apply to each rotor, expressed in rad/s\n \"\"\"\n return self._input_reference\n\n def update_input_reference(self, controls):\n \"\"\"Takes a list with the thrust controls received via mavlink and scales them in order to generated\n the equivalent angular velocities in rad/s\n\n Args:\n controls (list): A list of ints with thrust controls received via mavlink\n \"\"\"\n\n # Check if the number of controls received is correct\n if len(controls) < self.num_rotors:\n carb.log_warn(\"Did not receive enough inputs for all the rotors\")\n return\n\n # Update the desired reference for every rotor (and saturate according to the min and max values)\n for i in range(self.num_rotors):\n\n # Compute the actual velocity reference to apply to each rotor\n self._input_reference[i] = (controls[i] + self.input_offset[i]) * self.input_scaling[\n i\n ] + self.zero_position_armed[i]\n\n def zero_input_reference(self):\n \"\"\"\n When this method is called, the input_reference is updated such that every rotor is stopped\n \"\"\"\n self._input_reference = [0.0 for i in range(self.num_rotors)]\n\n\nclass MavlinkBackendConfig:\n \"\"\"\n An auxiliary data class used to store all the configurations for the mavlink communications.\n \"\"\"\n\n def __init__(self, config={}):\n \"\"\"\n Initialize the MavlinkBackendConfig class\n\n Args:\n config (dict): A Dictionary that contains all the parameters for configuring the Mavlink interface - it can be empty or only have some of the parameters used by this backend.\n \n Examples:\n The dictionary default parameters are\n\n >>> {\"vehicle_id\": 0, \n >>> \"connection_type\": \"tcpin\", \n >>> \"connection_ip\": \"localhost\",\n >>> \"connection_baseport\": 4560,\n >>> \"px4_autolaunch\": True,\n >>> \"px4_dir\": \"PegasusInterface().px4_path\",\n >>> \"px4_vehicle_model\": \"gazebo-classic_iris\",\n >>> \"enable_lockstep\": True,\n >>> \"num_rotors\": 4,\n >>> \"input_offset\": [0.0, 0.0, 0.0, 0.0],\n >>> \"input_scaling\": [1000.0, 1000.0, 1000.0, 1000.0],\n >>> \"zero_position_armed\": [100.0, 100.0, 100.0, 100.0],\n >>> \"update_rate\": 250.0\n >>> }\n \"\"\"\n\n # Configurations for the mavlink communication protocol (note: the vehicle id is sumed to the connection_baseport)\n self.vehicle_id = config.get(\"vehicle_id\", 0)\n self.connection_type = config.get(\"connection_type\", \"tcpin\")\n self.connection_ip = config.get(\"connection_ip\", \"localhost\")\n self.connection_baseport = config.get(\"connection_baseport\", 4560)\n\n # Configure whether to launch px4 in the background automatically or not for every vehicle launched\n self.px4_autolaunch: bool = config.get(\"px4_autolaunch\", True)\n self.px4_dir: str = config.get(\"px4_dir\", PegasusInterface().px4_path)\n self.px4_vehicle_model: str = config.get(\"px4_vehicle_model\", \"gazebo-classic_iris\")\n\n # Configurations to interpret the rotors control messages coming from mavlink\n self.enable_lockstep: bool = config.get(\"enable_lockstep\", True)\n self.num_rotors: int = config.get(\"num_rotors\", 4)\n self.input_offset = config.get(\"input_offset\", [0.0, 0.0, 0.0, 0.0])\n self.input_scaling = config.get(\"input_scaling\", [1000.0, 1000.0, 1000.0, 1000.0])\n self.zero_position_armed = config.get(\"zero_position_armed\", [100.0, 100.0, 100.0, 100.0])\n\n # The update rate at which we will be sending data to mavlink (TODO - remove this from here in the future\n # and infer directly from the function calls)\n self.update_rate: float = config.get(\"update_rate\", 250.0) # [Hz]\n\n\nclass MavlinkBackend(Backend):\n \"\"\" The Mavlink Backend used to receive the vehicle's state and sensor data in order to send to PX4 through mavlink. It also\n receives via mavlink the thruster commands to apply to each vehicle rotor.\n \"\"\"\n\n def __init__(self, config=MavlinkBackendConfig()):\n \"\"\"Initialize the MavlinkBackend\n\n Args:\n config (MavlinkBackendConfig): The configuration class for the MavlinkBackend. Defaults to MavlinkBackendConfig().\n \"\"\"\n\n # Initialize the Backend object\n super().__init__()\n\n # Setup the desired mavlink connection port\n # The connection will only be created once the simulation starts\n self._vehicle_id = config.vehicle_id\n self._connection = None\n self._connection_port = (\n config.connection_type\n + \":\"\n + config.connection_ip\n + \":\"\n + str(config.connection_baseport + config.vehicle_id)\n )\n\n # Check if we need to autolaunch px4 in the background or not\n self.px4_autolaunch: bool = config.px4_autolaunch\n self.px4_vehicle_model: str = config.px4_vehicle_model # only needed if px4_autolaunch == True\n self.px4_tool: PX4LaunchTool = None\n self.px4_dir: str = config.px4_dir\n\n # Set the update rate used for sending the messages (TODO - remove this hardcoded value from here)\n self._update_rate: float = config.update_rate\n self._time_step: float = 1.0 / self._update_rate # s\n\n self._is_running: bool = False\n\n # Vehicle Sensor data to send through mavlink\n self._sensor_data: SensorMsg = SensorMsg()\n\n # Vehicle Rotor data received from mavlink\n self._rotor_data: ThrusterControl = ThrusterControl(\n config.num_rotors, config.input_offset, config.input_scaling, config.zero_position_armed\n )\n\n # Vehicle actuator control data\n self._num_inputs: int = config.num_rotors\n self._input_reference: np.ndarray = np.zeros((self._num_inputs,))\n self._armed: bool = False\n\n self._input_offset: np.ndarray = np.zeros((self._num_inputs,))\n self._input_scaling: np.ndarray = np.zeros((self._num_inputs,))\n\n # Select whether lockstep is enabled\n self._enable_lockstep: bool = config.enable_lockstep\n\n # Auxiliar variables to handle the lockstep between receiving sensor data and actuator control\n self._received_first_actuator: bool = False\n\n self._received_actuator: bool = False\n\n # Auxiliar variables to check if we have already received an hearbeat from the software in the loop simulation\n self._received_first_hearbeat: bool = False\n\n self._last_heartbeat_sent_time = 0\n\n # Auxiliar variables for setting the u_time when sending sensor data to px4\n self._current_utime: int = 0\n\n def update_sensor(self, sensor_type: str, data):\n \"\"\"Method that is used as callback for the vehicle for every iteration that a sensor produces new data. \n Only the IMU, GPS, Barometer and Magnetometer sensor data are stored to be sent through mavlink. Every other \n sensor data that gets passed to this function is discarded.\n\n Args:\n sensor_type (str): A name that describes the type of sensor\n data (dict): A dictionary that contains the data produced by the sensor\n \"\"\"\n\n if sensor_type == \"IMU\":\n self.update_imu_data(data)\n elif sensor_type == \"GPS\":\n self.update_gps_data(data)\n elif sensor_type == \"Barometer\":\n self.update_bar_data(data)\n elif sensor_type == \"Magnetometer\":\n self.update_mag_data(data)\n # If the data received is not from one of the above sensors, then this backend does\n # not support that sensor and it will just ignore it\n else:\n pass\n\n def update_imu_data(self, data):\n \"\"\"Gets called by the 'update_sensor' method to update the current IMU data\n\n Args:\n data (dict): The data produced by an IMU sensor\n \"\"\"\n\n # Acelerometer data\n self._sensor_data.xacc = data[\"linear_acceleration\"][0]\n self._sensor_data.yacc = data[\"linear_acceleration\"][1]\n self._sensor_data.zacc = data[\"linear_acceleration\"][2]\n\n # Gyro data\n self._sensor_data.xgyro = data[\"angular_velocity\"][0]\n self._sensor_data.ygyro = data[\"angular_velocity\"][1]\n self._sensor_data.zgyro = data[\"angular_velocity\"][2]\n\n # Signal that we have new IMU data\n self._sensor_data.new_imu_data = True\n self._sensor_data.received_first_imu = True\n\n def update_gps_data(self, data):\n \"\"\"Gets called by the 'update_sensor' method to update the current GPS data\n\n Args:\n data (dict): The data produced by an GPS sensor\n \"\"\"\n\n # GPS data\n self._sensor_data.fix_type = int(data[\"fix_type\"])\n self._sensor_data.latitude_deg = int(data[\"latitude\"] * 10000000)\n self._sensor_data.longitude_deg = int(data[\"longitude\"] * 10000000)\n self._sensor_data.altitude = int(data[\"altitude\"] * 1000)\n self._sensor_data.eph = int(data[\"eph\"])\n self._sensor_data.epv = int(data[\"epv\"])\n self._sensor_data.velocity = int(data[\"speed\"] * 100)\n self._sensor_data.velocity_north = int(data[\"velocity_north\"] * 100)\n self._sensor_data.velocity_east = int(data[\"velocity_east\"] * 100)\n self._sensor_data.velocity_down = int(data[\"velocity_down\"] * 100)\n self._sensor_data.cog = int(data[\"cog\"] * 100)\n self._sensor_data.satellites_visible = int(data[\"sattelites_visible\"])\n\n # Signal that we have new GPS data\n self._sensor_data.new_gps_data = True\n\n # Also update the groundtruth for the latitude and longitude\n self._sensor_data.sim_lat = int(data[\"latitude_gt\"] * 10000000)\n self._sensor_data.sim_lon = int(data[\"longitude_gt\"] * 10000000)\n self._sensor_data.sim_alt = int(data[\"altitude_gt\"] * 1000)\n\n def update_bar_data(self, data):\n \"\"\"Gets called by the 'update_sensor' method to update the current Barometer data\n\n Args:\n data (dict): The data produced by an Barometer sensor\n \"\"\"\n\n # Barometer data\n self._sensor_data.temperature = data[\"temperature\"]\n self._sensor_data.abs_pressure = data[\"absolute_pressure\"]\n self._sensor_data.pressure_alt = data[\"pressure_altitude\"]\n\n # Signal that we have new Barometer data\n self._sensor_data.new_bar_data = True\n\n def update_mag_data(self, data):\n \"\"\"Gets called by the 'update_sensor' method to update the current Vision data\n\n Args:\n data (dict): The data produced by an Vision sensor\n \"\"\"\n\n # Magnetometer data\n self._sensor_data.xmag = data[\"magnetic_field\"][0]\n self._sensor_data.ymag = data[\"magnetic_field\"][1]\n self._sensor_data.zmag = data[\"magnetic_field\"][2]\n\n # Signal that we have new Magnetometer data\n self._sensor_data.new_mag_data = True\n\n def update_vision_data(self, data):\n \"\"\"Method that 'in the future' will get called by the 'update_sensor' method to update the current Vision data\n This callback is currently not being called (TODO in a future simulator version)\n Args:\n data (dict): The data produced by an Vision sensor\n \"\"\"\n\n # Vision or MOCAP data\n self._sensor_data.vision_x = data[\"x\"]\n self._sensor_data.vision_y = data[\"y\"]\n self._sensor_data.vision_z = data[\"z\"]\n self._sensor_data.vision_roll = data[\"roll\"]\n self._sensor_data.vision_pitch = data[\"pitch\"]\n self._sensor_data.vision_yaw = data[\"yaw\"]\n\n # Signal that we have new vision or mocap data\n self._sensor_data.new_vision_data = True\n\n def update_state(self, state: State):\n \"\"\"Method that is used as callback and gets called at every physics step with the current state of the vehicle.\n This state is then stored in order to be sent as groundtruth via mavlink\n\n Args:\n state (State): The current state of the vehicle.\n \"\"\"\n\n # Get the quaternion in the convention [x, y, z, w]\n attitude = state.get_attitude_ned_frd()\n\n # Rotate the quaternion to the mavlink standard\n self._sensor_data.sim_attitude[0] = attitude[3]\n self._sensor_data.sim_attitude[1] = attitude[0]\n self._sensor_data.sim_attitude[2] = attitude[1]\n self._sensor_data.sim_attitude[3] = attitude[2]\n\n # Get the angular velocity\n ang_vel = state.get_angular_velocity_frd()\n self._sensor_data.sim_angular_vel[0] = ang_vel[0]\n self._sensor_data.sim_angular_vel[1] = ang_vel[1]\n self._sensor_data.sim_angular_vel[2] = ang_vel[2]\n\n # Get the acceleration\n acc_vel = state.get_linear_acceleration_ned()\n self._sensor_data.sim_acceleration[0] = int(acc_vel[0] * 1000)\n self._sensor_data.sim_acceleration[1] = int(acc_vel[1] * 1000)\n self._sensor_data.sim_acceleration[2] = int(acc_vel[2] * 1000)\n\n # Get the latitude, longitude and altitude directly from the GPS\n\n # Get the linear velocity of the vehicle in the inertial frame\n lin_vel = state.get_linear_velocity_ned()\n self._sensor_data.sim_velocity_inertial[0] = int(lin_vel[0] * 100)\n self._sensor_data.sim_velocity_inertial[1] = int(lin_vel[1] * 100)\n self._sensor_data.sim_velocity_inertial[2] = int(lin_vel[2] * 100)\n\n # Compute the air_speed - assumed indicated airspeed due to flow aligned with pitot (body x)\n body_vel = state.get_linear_body_velocity_ned_frd()\n self._sensor_data.sim_ind_airspeed = int(body_vel[0] * 100)\n self._sensor_data.sim_true_airspeed = int(np.linalg.norm(lin_vel) * 100) # TODO - add wind here\n\n self._sensor_data.new_sim_state = True\n\n def input_reference(self):\n \"\"\"Method that when implemented, should return a list of desired angular velocities to apply to the vehicle rotors\n \"\"\"\n return self._rotor_data.input_reference\n\n def __del__(self):\n \"\"\"Gets called when the MavlinkBackend object gets destroyed. When this happens, we make sure\n to close any mavlink connection open for this vehicle.\n \"\"\"\n\n # When this object gets destroyed, close the mavlink connection to free the communication port\n try:\n self._connection.close()\n self._connection = None\n except:\n carb.log_info(\"Mavlink connection was not closed, because it was never opened\")\n\n def start(self):\n \"\"\"Method that handles the begining of the simulation of vehicle. It will try to open the mavlink connection \n interface and also attemp to launch px4 in a background process if that option as specified in the config class\n \"\"\"\n\n # If we are already running the mavlink interface, then ignore the function call\n if self._is_running == True:\n return\n\n # If the connection no longer exists (we stoped and re-started the stream, then re_intialize the interface)\n if self._connection is None:\n self.re_initialize_interface()\n\n # Set the flag to signal that the mavlink transmission has started\n self._is_running = True\n\n # Launch the PX4 in the background if needed\n if self.px4_autolaunch and self.px4_tool is None:\n carb.log_info(\"Attempting to launch PX4 in background process\")\n self.px4_tool = PX4LaunchTool(self.px4_dir, self._vehicle_id, self.px4_vehicle_model)\n self.px4_tool.launch_px4()\n\n def stop(self):\n \"\"\"Method that when called will handle the stopping of the simulation of vehicle. It will make sure that any open\n mavlink connection will be closed and also that the PX4 background process gets killed (if it was auto-initialized)\n \"\"\"\n\n # If the simulation was already stoped, then ignore the function call\n if self._is_running == False:\n return\n\n # Set the flag so that we are no longer running the mavlink interface\n self._is_running = False\n\n # Close the mavlink connection\n self._connection.close()\n self._connection = None\n\n # Close the PX4 if it was running\n if self.px4_autolaunch and self.px4_autolaunch is not None:\n carb.log_info(\"Attempting to kill PX4 background process\")\n self.px4_tool.kill_px4()\n self.px4_tool = None\n\n def reset(self):\n \"\"\"For now does nothing. Here for compatibility purposes only\n \"\"\"\n return\n\n def re_initialize_interface(self):\n \"\"\"Auxiliar method used to get the MavlinkInterface to reset the MavlinkInterface to its initial state\n \"\"\"\n\n self._is_running = False\n\n # Restart the sensor data\n self._sensor_data = SensorMsg()\n\n # Restart the connection\n self._connection = mavutil.mavlink_connection(self._connection_port)\n\n # Auxiliar variables to handle the lockstep between receiving sensor data and actuator control\n self._received_first_actuator: bool = False\n self._received_actuator: bool = False\n\n # Auxiliar variables to check if we have already received an hearbeat from the software in the loop simulation\n self._received_first_hearbeat: bool = False\n\n self._last_heartbeat_sent_time = 0\n\n def wait_for_first_hearbeat(self):\n \"\"\"\n Responsible for waiting for the first hearbeat. This method is locking and will only return\n if an hearbeat is received via mavlink. When this first heartbeat is received poll for mavlink messages\n \"\"\"\n\n carb.log_warn(\"Waiting for first hearbeat\")\n result = self._connection.wait_heartbeat(blocking=False)\n\n if result is not None:\n self._received_first_hearbeat = True\n carb.log_warn(\"Received first hearbeat\")\n\n def update(self, dt):\n \"\"\"\n Method that is called at every physics step to send data to px4 and receive the control inputs via mavlink\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n\n # Check for the first hearbeat on the first few iterations\n if not self._received_first_hearbeat:\n self.wait_for_first_hearbeat()\n return\n\n # Check if we have already received IMU data. If not, start the lockstep and wait for more data\n if self._sensor_data.received_first_imu:\n while not self._sensor_data.new_imu_data and self._is_running:\n # Just go for the next update and then try to check if we have new simulated sensor data\n # DO not continue and get mavlink thrusters commands until we have simulated IMU data available\n return\n\n # Check if we have received any mavlink messages\n self.poll_mavlink_messages()\n\n # Send hearbeats at 1Hz\n if (time.time() - self._last_heartbeat_sent_time) > 1.0 or self._received_first_hearbeat == False:\n self.send_heartbeat()\n self._last_heartbeat_sent_time = time.time()\n\n # Update the current u_time for px4\n self._current_utime += int(dt * 1000000)\n\n # Send sensor messages\n self.send_sensor_msgs(self._current_utime)\n\n # Send the GPS messages\n self.send_gps_msgs(self._current_utime)\n\n def poll_mavlink_messages(self):\n \"\"\"\n Method that is used to check if new mavlink messages were received\n \"\"\"\n\n # If we have not received the first hearbeat yet, do not poll for mavlink messages\n if self._received_first_hearbeat == False:\n return\n\n # Check if we need to lock and wait for actuator control data\n needs_to_wait_for_actuator: bool = self._received_first_actuator and self._enable_lockstep\n\n # Start by assuming that we have not received data for the actuators for the current step\n self._received_actuator = False\n\n # Use this loop to emulate a do-while loop (make sure this runs at least once)\n while True:\n\n # Try to get a message\n msg = self._connection.recv_match(blocking=needs_to_wait_for_actuator)\n\n # If a message was received\n if msg is not None:\n\n # Check if it is of the type that contains actuator controls\n if msg.id == mavutil.mavlink.MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS:\n\n self._received_first_actuator = True\n self._received_actuator = True\n\n # Handle the control of the actuation commands received by PX4\n self.handle_control(msg.time_usec, msg.controls, msg.mode, msg.flags)\n\n # Check if we do not need to wait for an actuator message or we just received actuator input\n # If so, break out of the infinite loop\n if not needs_to_wait_for_actuator or self._received_actuator:\n break\n\n def send_heartbeat(self, mav_type=mavutil.mavlink.MAV_TYPE_GENERIC):\n \"\"\"\n Method that is used to publish an heartbear through mavlink protocol\n\n Args: \n mav_type (int): The ID that indicates the type of vehicle. Defaults to MAV_TYPE_GENERIC=0 \n \"\"\"\n\n carb.log_info(\"Sending heartbeat\")\n\n # Note: to know more about these functions, go to pymavlink->dialects->v20->standard.py\n # This contains the definitions for sending the hearbeat and simulated sensor messages\n self._connection.mav.heartbeat_send(mav_type, mavutil.mavlink.MAV_AUTOPILOT_INVALID, 0, 0, 0)\n\n def send_sensor_msgs(self, time_usec: int):\n \"\"\"\n Method that when invoked, will send the simulated sensor data through mavlink\n\n Args:\n time_usec (int): The total time elapsed since the simulation started\n \"\"\"\n carb.log_info(\"Sending sensor msgs\")\n\n # Check which sensors have new data to send\n fields_updated: int = 0\n\n if self._sensor_data.new_imu_data:\n # Set the bit field to signal that we are sending updated accelerometer and gyro data\n fields_updated = fields_updated | SensorSource.ACCEL | SensorSource.GYRO\n self._sensor_data.new_imu_data = False\n\n if self._sensor_data.new_mag_data:\n # Set the bit field to signal that we are sending updated magnetometer data\n fields_updated = fields_updated | SensorSource.MAG\n self._sensor_data.new_mag_data = False\n\n if self._sensor_data.new_bar_data:\n # Set the bit field to signal that we are sending updated barometer data\n fields_updated = fields_updated | SensorSource.BARO\n self._sensor_data.new_bar_data = False\n\n if self._sensor_data.new_press_data:\n # Set the bit field to signal that we are sending updated diff pressure data\n fields_updated = fields_updated | SensorSource.DIFF_PRESS\n self._sensor_data.new_press_data = False\n\n try:\n self._connection.mav.hil_sensor_send(\n time_usec,\n self._sensor_data.xacc,\n self._sensor_data.yacc,\n self._sensor_data.zacc,\n self._sensor_data.xgyro,\n self._sensor_data.ygyro,\n self._sensor_data.zgyro,\n self._sensor_data.xmag,\n self._sensor_data.ymag,\n self._sensor_data.zmag,\n self._sensor_data.abs_pressure,\n self._sensor_data.diff_pressure,\n self._sensor_data.pressure_alt,\n self._sensor_data.altitude,\n fields_updated,\n )\n except:\n carb.log_warn(\"Could not send sensor data through mavlink\")\n\n def send_gps_msgs(self, time_usec: int):\n \"\"\"\n Method that is used to send simulated GPS data through the mavlink protocol.\n\n Args:\n time_usec (int): The total time elapsed since the simulation started\n \"\"\"\n carb.log_info(\"Sending GPS msgs\")\n\n # Do not send GPS data, if no new data was received\n if not self._sensor_data.new_gps_data:\n return\n\n self._sensor_data.new_gps_data = False\n\n # Latitude, longitude and altitude (all in integers)\n try:\n self._connection.mav.hil_gps_send(\n time_usec,\n self._sensor_data.fix_type,\n self._sensor_data.latitude_deg,\n self._sensor_data.longitude_deg,\n self._sensor_data.altitude,\n self._sensor_data.eph,\n self._sensor_data.epv,\n self._sensor_data.velocity,\n self._sensor_data.velocity_north,\n self._sensor_data.velocity_east,\n self._sensor_data.velocity_down,\n self._sensor_data.cog,\n self._sensor_data.satellites_visible,\n )\n except:\n carb.log_warn(\"Could not send gps data through mavlink\")\n\n def send_vision_msgs(self, time_usec: int):\n \"\"\"\n Method that is used to send simulated vision/mocap data through the mavlink protocol.\n\n Args:\n time_usec (int): The total time elapsed since the simulation started\n \"\"\"\n carb.log_info(\"Sending vision/mocap msgs\")\n\n # Do not send vision/mocap data, if not new data was received\n if not self._sensor_data.new_vision_data:\n return\n\n self._sensor_data.new_vision_data = False\n\n try:\n self._connection.mav.global_vision_position_estimate_send(\n time_usec,\n self._sensor_data.vision_x,\n self._sensor_data.vision_y,\n self._sensor_data.vision_z,\n self._sensor_data.vision_roll,\n self._sensor_data.vision_pitch,\n self._sensor_data.vision_yaw,\n self._sensor_data.vision_covariance,\n )\n except:\n carb.log_warn(\"Could not send vision/mocap data through mavlink\")\n\n def send_ground_truth(self, time_usec: int):\n \"\"\"\n Method that is used to send the groundtruth data of the vehicle through mavlink\n\n Args:\n time_usec (int): The total time elapsed since the simulation started\n \"\"\"\n\n carb.log_info(\"Sending groundtruth msgs\")\n\n # Do not send vision/mocap data, if not new data was received\n if not self._sensor_data.new_sim_state or self._sensor_data.sim_alt == 0:\n return\n\n self._sensor_data.new_sim_state = False\n\n try:\n self._connection.mav.hil_state_quaternion_send(\n time_usec,\n self._sensor_data.sim_attitude,\n self._sensor_data.sim_angular_vel[0],\n self._sensor_data.sim_angular_vel[1],\n self._sensor_data.sim_angular_vel[2],\n self._sensor_data.sim_lat,\n self._sensor_data.sim_lon,\n self._sensor_data.sim_alt,\n self._sensor_data.sim_velocity_inertial[0],\n self._sensor_data.sim_velocity_inertial[1],\n self._sensor_data.sim_velocity_inertial[2],\n self._sensor_data.sim_ind_airspeed,\n self._sensor_data.sim_true_airspeed,\n self._sensor_data.sim_acceleration[0],\n self._sensor_data.sim_acceleration[1],\n self._sensor_data.sim_acceleration[2],\n )\n except:\n carb.log_warn(\"Could not send groundtruth through mavlink\")\n\n def handle_control(self, time_usec, controls, mode, flags):\n \"\"\"\n Method that when received a control message, compute the forces simulated force that should be applied\n on each rotor of the vehicle\n\n Args:\n time_usec (int): The total time elapsed since the simulation started - Ignored argument\n controls (list): A list of ints which contains the thrust_control received via mavlink\n flags: Ignored argument\n \"\"\"\n\n # Check if the vehicle is armed - Note: here we have to add a +1 since the code for armed is 128, but\n # pymavlink is return 129 (the end of the buffer)\n if mode == mavutil.mavlink.MAV_MODE_FLAG_SAFETY_ARMED + 1:\n\n carb.log_info(\"Parsing control input\")\n\n # Set the rotor target speeds\n self._rotor_data.update_input_reference(controls)\n\n # If the vehicle is not armed, do not rotate the propellers\n else:\n self._rotor_data.zero_input_reference()\n"},"size":{"kind":"number","value":34342,"string":"34,342"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":39.884523762042235,"string":"39.884524"},"max_line_length":{"kind":"number","value":186,"string":"186"},"alphanum_fraction":{"kind":"number","value":0.6169704734547501,"string":"0.61697"}}},{"rowIdx":80,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/tools/px4_launch_tool.py"},"content":{"kind":"string","value":"\"\"\"\n| File: px4_launch_tool.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Description: Defines an auxiliary tool to launch the PX4 process in the background\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\n\n# System tools used to launch the px4 process in the brackground\nimport os\nimport tempfile\nimport subprocess\n\n\nclass PX4LaunchTool:\n \"\"\"\n A class that manages the start/stop of a px4 process. It requires only the path to the PX4 installation (assuming that\n PX4 was already built with 'make px4_sitl_default none'), the vehicle id and the vehicle model. \n \"\"\"\n\n def __init__(self, px4_dir, vehicle_id: int = 0, px4_model: str = \"gazebo-classic_iris\"):\n \"\"\"Construct the PX4LaunchTool object\n\n Args:\n px4_dir (str): A string with the path to the PX4-Autopilot directory\n vehicle_id (int): The ID of the vehicle. Defaults to 0.\n px4_model (str): The vehicle model. Defaults to \"iris\".\n \"\"\"\n\n # Attribute that will hold the px4 process once it is running\n self.px4_process = None\n\n # The vehicle id (used for the mavlink port open in the system)\n self.vehicle_id = vehicle_id\n\n # Configurations to whether autostart px4 (SITL) automatically or have the user launch it manually on another\n # terminal\n self.px4_dir = px4_dir\n self.rc_script = self.px4_dir + \"/ROMFS/px4fmu_common/init.d-posix/rcS\"\n\n # Create a temporary filesystem for px4 to write data to/from (and modify the origin rcS files)\n self.root_fs = tempfile.TemporaryDirectory()\n\n # Set the environement variables that let PX4 know which vehicle model to use internally\n self.environment = os.environ\n self.environment[\"PX4_SIM_MODEL\"] = px4_model\n\n def launch_px4(self):\n \"\"\"\n Method that will launch a px4 instance with the specified configuration\n \"\"\"\n self.px4_process = subprocess.Popen(\n [\n self.px4_dir + \"/build/px4_sitl_default/bin/px4\",\n self.px4_dir + \"/ROMFS/px4fmu_common/\",\n \"-s\",\n self.rc_script,\n \"-i\",\n str(self.vehicle_id),\n \"-d\",\n ],\n cwd=self.root_fs.name,\n shell=False,\n env=self.environment,\n )\n\n def kill_px4(self):\n \"\"\"\n Method that will kill a px4 instance with the specified configuration\n \"\"\"\n if self.px4_process is not None:\n self.px4_process.kill()\n self.px4_process = None\n\n def __del__(self):\n \"\"\"\n If the px4 process is still running when the PX4 launch tool object is whiped from memory, then make sure\n we kill the px4 instance so we don't end up with hanged px4 instances\n \"\"\"\n\n # Make sure the PX4 process gets killed\n if self.px4_process:\n self.kill_px4()\n\n # Make sure we clean the temporary filesystem used for the simulation\n self.root_fs.cleanup()\n\n\n# ---- Code used for debugging the px4 tool ----\ndef main():\n\n px4_tool = PX4LaunchTool(os.environ[\"HOME\"] + \"/PX4-Autopilot\")\n px4_tool.launch_px4()\n\n import time\n\n time.sleep(60)\n\n\nif __name__ == \"__main__\":\n main()\n"},"size":{"kind":"number","value":3332,"string":"3,332"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":31.99999968316832,"string":"32"},"max_line_length":{"kind":"number","value":122,"string":"122"},"alphanum_fraction":{"kind":"number","value":0.6125450178233659,"string":"0.612545"}}},{"rowIdx":81,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/vehicle.py"},"content":{"kind":"string","value":"\"\"\"\n| File: vehicle.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of the Vehicle class which is used as the base for all the vehicles.\n\"\"\"\n\n# Numerical computations\nimport numpy as np\nfrom scipy.spatial.transform import Rotation\n\n# Low level APIs\nimport carb\nfrom pxr import Usd, Gf\n\n# High level Isaac sim APIs\nimport omni.usd\nfrom omni.isaac.core.world import World\nfrom omni.isaac.core.utils.prims import define_prim, get_prim_at_path\nfrom omni.usd import get_stage_next_free_path\nfrom omni.isaac.core.robots.robot import Robot\n\n# Extension APIs\nfrom pegasus.simulator.logic.state import State\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\nfrom pegasus.simulator.logic.vehicle_manager import VehicleManager\n\n\ndef get_world_transform_xform(prim: Usd.Prim):\n \"\"\"\n Get the local transformation of a prim using omni.usd.get_world_transform_matrix().\n See https://docs.omniverse.nvidia.com/kit/docs/omni.usd/latest/omni.usd/omni.usd.get_world_transform_matrix.html\n Args:\n prim (Usd.Prim): The prim to calculate the world transformation.\n Returns:\n A tuple of:\n - Translation vector.\n - Rotation quaternion, i.e. 3d vector plus angle.\n - Scale vector.\n \"\"\"\n world_transform: Gf.Matrix4d = omni.usd.get_world_transform_matrix(prim)\n rotation: Gf.Rotation = world_transform.ExtractRotation()\n return rotation\n\n\nclass Vehicle(Robot):\n \n def __init__(\n self,\n stage_prefix: str,\n usd_path: str = None,\n init_pos=[0.0, 0.0, 0.0],\n init_orientation=[0.0, 0.0, 0.0, 1.0],\n ):\n \"\"\"\n Class that initializes a vehicle in the isaac sim's curent stage\n\n Args:\n stage_prefix (str): The name the vehicle will present in the simulator when spawned. Defaults to \"quadrotor\".\n usd_path (str): The USD file that describes the looks and shape of the vehicle. Defaults to \"\".\n init_pos (list): The initial position of the vehicle in the inertial frame (in ENU convention). Defaults to [0.0, 0.0, 0.0].\n init_orientation (list): The initial orientation of the vehicle in quaternion [qx, qy, qz, qw]. Defaults to [0.0, 0.0, 0.0, 1.0].\n \"\"\"\n\n # Get the current world at which we want to spawn the vehicle\n self._world = PegasusInterface().world\n self._current_stage = self._world.stage\n\n # Save the name with which the vehicle will appear in the stage\n # and the name of the .usd file that contains its description\n self._stage_prefix = get_stage_next_free_path(self._current_stage, stage_prefix, False)\n self._usd_file = usd_path\n\n # Get the vehicle name by taking the last part of vehicle stage prefix\n self._vehicle_name = self._stage_prefix.rpartition(\"/\")[-1]\n\n # Spawn the vehicle primitive in the world's stage\n self._prim = define_prim(self._stage_prefix, \"Xform\")\n self._prim = get_prim_at_path(self._stage_prefix)\n self._prim.GetReferences().AddReference(self._usd_file)\n\n # Initialize the \"Robot\" class\n # Note: we need to change the rotation to have qw first, because NVidia\n # does not keep a standard of quaternions inside its own libraries (not good, but okay)\n super().__init__(\n prim_path=self._stage_prefix,\n name=self._stage_prefix,\n position=init_pos,\n orientation=[init_orientation[3], init_orientation[0], init_orientation[1], init_orientation[2]],\n articulation_controller=None,\n )\n\n # Add this object for the world to track, so that if we clear the world, this object is deleted from memory and\n # as a consequence, from the VehicleManager as well\n self._world.scene.add(self)\n\n # Add the current vehicle to the vehicle manager, so that it knows\n # that a vehicle was instantiated\n VehicleManager.get_vehicle_manager().add_vehicle(self._stage_prefix, self)\n\n # Variable that will hold the current state of the vehicle\n self._state = State()\n\n # Motor that is given as reference\n self._motor_speed = []\n\n # Add a callback to the physics engine to update the current state of the system\n self._world.add_physics_callback(self._stage_prefix + \"/state\", self.update_state)\n\n # Add the update method to the physics callback if the world was received\n # so that we can apply forces and torques to the vehicle. Note, this method should\n # be implemented in classes that inherit the vehicle object\n self._world.add_physics_callback(self._stage_prefix + \"/update\", self.update)\n\n # Set the flag that signals if the simulation is running or not\n self._sim_running = False\n\n # Add a callback to start/stop of the simulation once the play/stop button is hit\n self._world.add_timeline_callback(self._stage_prefix + \"/start_stop_sim\", self.sim_start_stop)\n\n def __del__(self):\n \"\"\"\n Method that is invoked when a vehicle object gets destroyed. When this happens, we also invoke the \n 'remove_vehicle' from the VehicleManager in order to remove the vehicle from the list of active vehicles.\n \"\"\"\n\n # Remove this object from the vehicleHandler\n VehicleManager.get_vehicle_manager().remove_vehicle(self._stage_prefix)\n\n \"\"\"\n Properties\n \"\"\"\n\n @property\n def state(self):\n \"\"\"The state of the vehicle.\n\n Returns:\n State: The current state of the vehicle, i.e., position, orientation, linear and angular velocities...\n \"\"\"\n return self._state\n \n @property\n def vehicle_name(self) -> str:\n \"\"\"Vehicle name.\n\n Returns:\n Vehicle name (str): last prim name in vehicle prim path\n \"\"\"\n return self._vehicle_name\n\n \"\"\"\n Operations\n \"\"\"\n\n def sim_start_stop(self, event):\n \"\"\"\n Callback that is called every time there is a timeline event such as starting/stoping the simulation.\n\n Args:\n event: A timeline event generated from Isaac Sim, such as starting or stoping the simulation.\n \"\"\"\n\n # If the start/stop button was pressed, then call the start and stop methods accordingly\n if self._world.is_playing() and self._sim_running == False:\n self._sim_running = True\n self.start()\n\n if self._world.is_stopped() and self._sim_running == True:\n self._sim_running = False\n self.stop()\n\n def apply_force(self, force, pos=[0.0, 0.0, 0.0], body_part=\"/body\"):\n \"\"\"\n Method that will apply a force on the rigidbody, on the part specified in the 'body_part' at its relative position\n given by 'pos' (following a FLU) convention. \n\n Args:\n force (list): A 3-dimensional vector of floats with the force [Fx, Fy, Fz] on the body axis of the vehicle according to a FLU convention.\n pos (list): _description_. Defaults to [0.0, 0.0, 0.0].\n body_part (str): . Defaults to \"/body\".\n \"\"\"\n\n # Get the handle of the rigidbody that we will apply the force to\n rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + body_part)\n\n # Apply the force to the rigidbody. The force should be expressed in the rigidbody frame\n self._world.dc_interface.apply_body_force(rb, carb._carb.Float3(force), carb._carb.Float3(pos), False)\n\n def apply_torque(self, torque, body_part=\"/body\"):\n \"\"\"\n Method that when invoked applies a given torque vector to //\"body\" or to //.\n\n Args:\n torque (list): A 3-dimensional vector of floats with the force [Tx, Ty, Tz] on the body axis of the vehicle according to a FLU convention.\n body_part (str): . Defaults to \"/body\".\n \"\"\"\n\n # Get the handle of the rigidbody that we will apply a torque to\n rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + body_part)\n\n # Apply the torque to the rigidbody. The torque should be expressed in the rigidbody frame\n self._world.dc_interface.apply_body_torque(rb, carb._carb.Float3(torque), False)\n\n def update_state(self, dt: float):\n \"\"\"\n Method that is called at every physics step to retrieve and update the current state of the vehicle, i.e., get\n the current position, orientation, linear and angular velocities and acceleration of the vehicle.\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n\n # Get the body frame interface of the vehicle (this will be the frame used to get the position, orientation, etc.)\n body = self._world.dc_interface.get_rigid_body(self._stage_prefix + \"/body\")\n\n # Get the current position and orientation in the inertial frame\n pose = self._world.dc_interface.get_rigid_body_pose(body)\n\n # Get the attitude according to the convention [w, x, y, z]\n prim = self._world.stage.GetPrimAtPath(self._stage_prefix + \"/body\")\n rotation_quat = get_world_transform_xform(prim).GetQuaternion()\n rotation_quat_real = rotation_quat.GetReal()\n rotation_quat_img = rotation_quat.GetImaginary()\n\n # Get the angular velocity of the vehicle expressed in the body frame of reference\n ang_vel = self._world.dc_interface.get_rigid_body_angular_velocity(body)\n\n # The linear velocity [x_dot, y_dot, z_dot] of the vehicle's body frame expressed in the inertial frame of reference\n linear_vel = self._world.dc_interface.get_rigid_body_linear_velocity(body)\n\n # Get the linear acceleration of the body relative to the inertial frame, expressed in the inertial frame\n # Note: we must do this approximation, since the Isaac sim does not output the acceleration of the rigid body directly\n linear_acceleration = (np.array(linear_vel) - self._state.linear_velocity) / dt\n\n # Update the state variable X = [x,y,z]\n self._state.position = np.array(pose.p)\n\n # Get the quaternion according in the [qx,qy,qz,qw] standard\n self._state.attitude = np.array(\n [rotation_quat_img[0], rotation_quat_img[1], rotation_quat_img[2], rotation_quat_real]\n )\n\n # Express the velocity of the vehicle in the inertial frame X_dot = [x_dot, y_dot, z_dot]\n self._state.linear_velocity = np.array(linear_vel)\n\n # The linear velocity V =[u,v,w] of the vehicle's body frame expressed in the body frame of reference\n # Note that: x_dot = Rot * V\n self._state.linear_body_velocity = (\n Rotation.from_quat(self._state.attitude).inv().apply(self._state.linear_velocity)\n )\n\n # omega = [p,q,r]\n self._state.angular_velocity = Rotation.from_quat(self._state.attitude).inv().apply(np.array(ang_vel))\n\n # The acceleration of the vehicle expressed in the inertial frame X_ddot = [x_ddot, y_ddot, z_ddot]\n self._state.linear_acceleration = linear_acceleration\n\n def start(self):\n \"\"\"\n Method that should be implemented by the class that inherits the vehicle object.\n \"\"\"\n pass\n\n def stop(self):\n \"\"\"\n Method that should be implemented by the class that inherits the vehicle object.\n \"\"\"\n pass\n\n def update(self, dt: float):\n \"\"\"\n Method that computes and applies the forces to the vehicle in\n simulation based on the motor speed. This method must be implemented\n by a class that inherits this type and it's called periodically by the physics engine.\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n pass\n"},"size":{"kind":"number","value":11970,"string":"11,970"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":41.60142333949671,"string":"41.601423"},"max_line_length":{"kind":"number","value":150,"string":"150"},"alphanum_fraction":{"kind":"number","value":0.6531328320256363,"string":"0.653133"}}},{"rowIdx":82,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/multirotor.py"},"content":{"kind":"string","value":"\"\"\"\n| File: multirotor.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n| Description: Definition of the Multirotor class which is used as the base for all the multirotor vehicles.\n\"\"\"\n\nimport numpy as np\n\n# The vehicle interface\nfrom pegasus.simulator.logic.vehicles.vehicle import Vehicle\n\n# Mavlink interface\nfrom pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend\n\n# Sensors and dynamics setup\nfrom pegasus.simulator.logic.dynamics import LinearDrag\nfrom pegasus.simulator.logic.thrusters import QuadraticThrustCurve\nfrom pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS\nfrom pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface\n\nclass MultirotorConfig:\n \"\"\"\n A data class that is used for configuring a Multirotor\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Initialization of the MultirotorConfig class\n \"\"\"\n\n # Stage prefix of the vehicle when spawning in the world\n self.stage_prefix = \"quadrotor\"\n\n # The USD file that describes the visual aspect of the vehicle (and some properties such as mass and moments of inertia)\n self.usd_file = \"\"\n\n # The default thrust curve for a quadrotor and dynamics relating to drag\n self.thrust_curve = QuadraticThrustCurve()\n self.drag = LinearDrag([0.50, 0.30, 0.0])\n\n # The default sensors for a quadrotor\n self.sensors = [Barometer(), IMU(), Magnetometer(), GPS()]\n\n # The default graphs\n self.graphs = []\n\n # The backends for actually sending commands to the vehicle. By default use mavlink (with default mavlink configurations)\n # [Can be None as well, if we do not desired to use PX4 with this simulated vehicle]. It can also be a ROS2 backend\n # or your own custom Backend implementation!\n self.backends = [MavlinkBackend()]\n\n\nclass Multirotor(Vehicle):\n \"\"\"Multirotor class - It defines a base interface for creating a multirotor\n \"\"\"\n def __init__(\n self,\n # Simulation specific configurations\n stage_prefix: str = \"quadrotor\",\n usd_file: str = \"\",\n vehicle_id: int = 0,\n # Spawning pose of the vehicle\n init_pos=[0.0, 0.0, 0.07],\n init_orientation=[0.0, 0.0, 0.0, 1.0],\n config=MultirotorConfig(),\n ):\n \"\"\"Initializes the multirotor object\n\n Args:\n stage_prefix (str): The name the vehicle will present in the simulator when spawned. Defaults to \"quadrotor\".\n usd_file (str): The USD file that describes the looks and shape of the vehicle. Defaults to \"\".\n vehicle_id (int): The id to be used for the vehicle. Defaults to 0.\n init_pos (list): The initial position of the vehicle in the inertial frame (in ENU convention). Defaults to [0.0, 0.0, 0.07].\n init_orientation (list): The initial orientation of the vehicle in quaternion [qx, qy, qz, qw]. Defaults to [0.0, 0.0, 0.0, 1.0].\n config (_type_, optional): _description_. Defaults to MultirotorConfig().\n \"\"\"\n\n # 1. Initiate the Vehicle object itself\n super().__init__(stage_prefix, usd_file, init_pos, init_orientation)\n\n # 2. Initialize all the vehicle sensors\n self._sensors = config.sensors\n for sensor in self._sensors:\n sensor.initialize(PegasusInterface().latitude, PegasusInterface().longitude, PegasusInterface().altitude)\n\n # Add callbacks to the physics engine to update each sensor at every timestep\n # and let the sensor decide depending on its internal update rate whether to generate new data\n self._world.add_physics_callback(self._stage_prefix + \"/Sensors\", self.update_sensors)\n\n # 3. Initialize all the vehicle graphs\n self._graphs = config.graphs\n for graph in self._graphs:\n graph.initialize(self)\n\n # 4. Setup the dynamics of the system\n # Get the thrust curve of the vehicle from the configuration\n self._thrusters = config.thrust_curve\n self._drag = config.drag\n\n # 5. Save the backend interface (if given in the configuration of the multirotor)\n # and initialize them\n self._backends = config.backends\n for backend in self._backends:\n backend.initialize(self)\n\n # Add a callbacks for the\n self._world.add_physics_callback(self._stage_prefix + \"/mav_state\", self.update_sim_state)\n\n def update_sensors(self, dt: float):\n \"\"\"Callback that is called at every physics steps and will call the sensor.update method to generate new\n sensor data. For each data that the sensor generates, the backend.update_sensor method will also be called for\n every backend. For example, if new data is generated for an IMU and we have a MavlinkBackend, then the update_sensor\n method will be called for that backend so that this data can latter be sent thorugh mavlink.\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n\n # Call the update method for the sensor to update its values internally (if applicable)\n for sensor in self._sensors:\n sensor_data = sensor.update(self._state, dt)\n\n # If some data was updated and we have a mavlink backend or ros backend (or other), then just update it\n if sensor_data is not None:\n for backend in self._backends:\n backend.update_sensor(sensor.sensor_type, sensor_data)\n\n def update_sim_state(self, dt: float):\n \"\"\"\n Callback that is used to \"send\" the current state for each backend being used to control the vehicle. This callback\n is called on every physics step.\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n for backend in self._backends:\n backend.update_state(self._state)\n\n def start(self):\n \"\"\"\n Intializes the communication with all the backends. This method is invoked automatically when the simulation starts\n \"\"\"\n for backend in self._backends:\n backend.start()\n\n def stop(self):\n \"\"\"\n Signal all the backends that the simulation has stoped. This method is invoked automatically when the simulation stops\n \"\"\"\n for backend in self._backends:\n backend.stop()\n\n def update(self, dt: float):\n \"\"\"\n Method that computes and applies the forces to the vehicle in simulation based on the motor speed. \n This method must be implemented by a class that inherits this type. This callback\n is called on every physics step.\n\n Args:\n dt (float): The time elapsed between the previous and current function calls (s).\n \"\"\"\n\n # Get the articulation root of the vehicle\n articulation = self._world.dc_interface.get_articulation(self._stage_prefix)\n\n # Get the desired angular velocities for each rotor from the first backend (can be mavlink or other) expressed in rad/s\n if len(self._backends) != 0:\n desired_rotor_velocities = self._backends[0].input_reference()\n else:\n desired_rotor_velocities = [0.0 for i in range(self._thrusters._num_rotors)]\n\n # Input the desired rotor velocities in the thruster model\n self._thrusters.set_input_reference(desired_rotor_velocities)\n\n # Get the desired forces to apply to the vehicle\n forces_z, _, rolling_moment = self._thrusters.update(self._state, dt)\n\n # Apply force to each rotor\n for i in range(4):\n\n # Apply the force in Z on the rotor frame\n self.apply_force([0.0, 0.0, forces_z[i]], body_part=\"/rotor\" + str(i))\n\n # Generate the rotating propeller visual effect\n self.handle_propeller_visual(i, forces_z[i], articulation)\n\n # Apply the torque to the body frame of the vehicle that corresponds to the rolling moment\n self.apply_torque([0.0, 0.0, rolling_moment], \"/body\")\n\n # Compute the total linear drag force to apply to the vehicle's body frame\n drag = self._drag.update(self._state, dt)\n self.apply_force(drag, body_part=\"/body\")\n\n # Call the update methods in all backends\n for backend in self._backends:\n backend.update(dt)\n\n def handle_propeller_visual(self, rotor_number, force: float, articulation):\n \"\"\"\n Auxiliar method used to set the joint velocity of each rotor (for animation purposes) based on the \n amount of force being applied on each joint\n\n Args:\n rotor_number (int): The number of the rotor to generate the rotation animation\n force (float): The force that is being applied on that rotor\n articulation (_type_): The articulation group the joints of the rotors belong to\n \"\"\"\n\n # Rotate the joint to yield the visual of a rotor spinning (for animation purposes only)\n joint = self._world.dc_interface.find_articulation_dof(articulation, \"joint\" + str(rotor_number))\n\n # Spinning when armed but not applying force\n if 0.0 < force < 0.1:\n self._world.dc_interface.set_dof_velocity(joint, 5 * self._thrusters.rot_dir[rotor_number])\n # Spinning when armed and applying force\n elif 0.1 <= force:\n self._world.dc_interface.set_dof_velocity(joint, 100 * self._thrusters.rot_dir[rotor_number])\n # Not spinning\n else:\n self._world.dc_interface.set_dof_velocity(joint, 0)\n\n def force_and_torques_to_velocities(self, force: float, torque: np.ndarray):\n \"\"\"\n Auxiliar method used to get the target angular velocities for each rotor, given the total desired thrust [N] and\n torque [Nm] to be applied in the multirotor's body frame.\n\n Note: This method assumes a quadratic thrust curve. This method will be improved in a future update,\n and a general thrust allocation scheme will be adopted. For now, it is made to work with multirotors directly.\n\n Args:\n force (np.ndarray): A vector of the force to be applied in the body frame of the vehicle [N]\n torque (np.ndarray): A vector of the torque to be applied in the body frame of the vehicle [Nm]\n\n Returns:\n list: A list of angular velocities [rad/s] to apply in reach rotor to accomplish suchs forces and torques\n \"\"\"\n\n # Get the body frame of the vehicle\n rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + \"/body\")\n\n # Get the rotors of the vehicle\n rotors = [self._world.dc_interface.get_rigid_body(self._stage_prefix + \"/rotor\" + str(i)) for i in range(self._thrusters._num_rotors)]\n\n # Get the relative position of the rotors with respect to the body frame of the vehicle (ignoring the orientation for now)\n relative_poses = self._world.dc_interface.get_relative_body_poses(rb, rotors)\n\n # Define the alocation matrix\n aloc_matrix = np.zeros((4, self._thrusters._num_rotors))\n \n # Define the first line of the matrix (T [N])\n aloc_matrix[0, :] = np.array(self._thrusters._rotor_constant) \n\n # Define the second and third lines of the matrix (\\tau_x [Nm] and \\tau_y [Nm])\n aloc_matrix[1, :] = np.array([relative_poses[i].p[1] * self._thrusters._rotor_constant[i] for i in range(self._thrusters._num_rotors)])\n aloc_matrix[2, :] = np.array([-relative_poses[i].p[0] * self._thrusters._rotor_constant[i] for i in range(self._thrusters._num_rotors)])\n\n # Define the forth line of the matrix (\\tau_z [Nm])\n aloc_matrix[3, :] = np.array([self._thrusters._rolling_moment_coefficient[i] * self._thrusters._rot_dir[i] for i in range(self._thrusters._num_rotors)])\n\n # Compute the inverse allocation matrix, so that we can get the angular velocities (squared) from the total thrust and torques\n aloc_inv = np.linalg.pinv(aloc_matrix)\n\n # Compute the target angular velocities (squared)\n squared_ang_vel = aloc_inv @ np.array([force, torque[0], torque[1], torque[2]])\n\n # Making sure that there is no negative value on the target squared angular velocities\n squared_ang_vel[squared_ang_vel < 0] = 0.0\n\n # ------------------------------------------------------------------------------------------------\n # Saturate the inputs while preserving their relation to each other, by performing a normalization\n # ------------------------------------------------------------------------------------------------\n max_thrust_vel_squared = np.power(self._thrusters.max_rotor_velocity[0], 2)\n max_val = np.max(squared_ang_vel)\n\n if max_val >= max_thrust_vel_squared:\n normalize = np.maximum(max_val / max_thrust_vel_squared, 1.0)\n\n squared_ang_vel = squared_ang_vel / normalize\n\n # Compute the angular velocities for each rotor in [rad/s]\n ang_vel = np.sqrt(squared_ang_vel)\n\n return ang_vel\n"},"size":{"kind":"number","value":13252,"string":"13,252"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":45.501754226309636,"string":"45.501754"},"max_line_length":{"kind":"number","value":160,"string":"160"},"alphanum_fraction":{"kind":"number","value":0.6445819498457152,"string":"0.644582"}}},{"rowIdx":83,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/multirotors/iris.py"},"content":{"kind":"string","value":"# Copyright (c) 2023, Marcelo Jacinto\n# All rights reserved.\n#\n# SPDX-License-Identifier: BSD-3-Clause\nfrom pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig\n\n# Sensors and dynamics setup\nfrom pegasus.simulator.logic.dynamics import LinearDrag\nfrom pegasus.simulator.logic.thrusters import QuadraticThrustCurve\nfrom pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS\n\n# Mavlink interface\nfrom pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend\n\n# Get the location of the IRIS asset\nfrom pegasus.simulator.params import ROBOTS\n\nclass IrisConfig(MultirotorConfig):\n\n def __init__(self):\n\n # Stage prefix of the vehicle when spawning in the world\n self.stage_prefix = \"quadrotor\"\n\n # The USD file that describes the visual aspect of the vehicle (and some properties such as mass and moments of inertia)\n self.usd_file = ROBOTS[\"Iris\"]\n\n # The default thrust curve for a quadrotor and dynamics relating to drag\n self.thrust_curve = QuadraticThrustCurve()\n self.drag = LinearDrag([0.50, 0.30, 0.0])\n\n # The default sensors for a quadrotor\n self.sensors = [Barometer(), IMU(), Magnetometer(), GPS()]\n\n # The backends for actually sending commands to the vehicle. By default use mavlink (with default mavlink configurations)\n # [Can be None as well, if we do not desired to use PX4 with this simulated vehicle]. It can also be a ROS2 backend\n # or your own custom Backend implementation!\n self.backends = [MavlinkBackend()]\n\nclass Iris(Multirotor):\n\n def __init__(self, id: int, world, init_pos=[0.0, 0.0, 0.07, init_orientation=[0.0, 0.0, 0.0, 1.0]], config=IrisConfig()):\n super.__init__(config.stage_prefix, config.usd_file, id, world, init_pos, init_orientation, config=config)"},"size":{"kind":"number","value":1850,"string":"1,850"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":42.04651065008115,"string":"42.046511"},"max_line_length":{"kind":"number","value":129,"string":"129"},"alphanum_fraction":{"kind":"number","value":0.7210810806913075,"string":"0.721081"}}},{"rowIdx":84,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/drag.py"},"content":{"kind":"string","value":"\"\"\"\n| File: drag.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Description: Base interface used to implement forces that should actuate on a rigidbody such as linear drag\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\nfrom pegasus.simulator.logic.state import State\n\nclass Drag:\n \"\"\"\n Class that serves as a template for the implementation of Drag forces that actuate on a rigid body\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Receives as input the drag coefficients of the vehicle as a 3x1 vector of constants\n \"\"\"\n\n @property\n def drag(self):\n \"\"\"The drag force to be applied on the body frame of the vehicle\n\n Returns:\n list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference\n frame, expressed in Newton (N) [dx, dy, dz]\n \"\"\"\n return [0.0, 0.0, 0.0]\n\n def update(self, state: State, dt: float):\n \"\"\"Method that should be implemented to update the drag force to be applied on the body frame of the vehicle\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference\n \"\"\"\n return [0.0, 0.0, 0.0]\n"},"size":{"kind":"number","value":1481,"string":"1,481"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":36.04999909875003,"string":"36.049999"},"max_line_length":{"kind":"number","value":128,"string":"128"},"alphanum_fraction":{"kind":"number","value":0.6495611069212957,"string":"0.649561"}}},{"rowIdx":85,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/linear_drag.py"},"content":{"kind":"string","value":"\"\"\"\n| File: linear_drag.py\n| Author: Marcelo Jacinto (marcelo.jacinto@tecnico.ulisboa.pt)\n| Description: Computes the forces that should actuate on a rigidbody affected by linear drag\n| License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved.\n\"\"\"\nimport numpy as np\nfrom pegasus.simulator.logic.dynamics.drag import Drag\nfrom pegasus.simulator.logic.state import State\n\nclass LinearDrag(Drag):\n \"\"\"\n Class that implements linear drag computations afftecting a rigid body. It inherits the Drag base class.\n \"\"\"\n\n def __init__(self, drag_coefficients=[0.0, 0.0, 0.0]):\n \"\"\"\n Receives as input the drag coefficients of the vehicle as a 3x1 vector of constants\n\n Args:\n drag_coefficients (list[float]): The constant linear drag coefficients to used to compute the total drag forces\n affecting the rigid body. The linear drag is given by diag(dx, dy, dz) * [v_x, v_y, v_z] where the velocities\n are expressed in the body frame of the rigid body (using the FRU frame convention).\n \"\"\"\n\n # Initialize the base Drag class\n super().__init__()\n\n # The linear drag coefficients of the vehicle's body frame\n self._drag_coefficients = np.diag(drag_coefficients)\n\n # The drag force to apply on the vehicle's body frame\n self._drag_force = np.array([0.0, 0.0, 0.0])\n\n @property\n def drag(self):\n \"\"\"The drag force to be applied on the body frame of the vehicle\n\n Returns:\n list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference\n frame, expressed in Newton (N) [dx, dy, dz]\n \"\"\"\n return self._drag_force\n\n def update(self, state: State, dt: float):\n \"\"\"Method that updates the drag force to be applied on the body frame of the vehicle. The total drag force\n applied on the body reference frame (FLU convention) is given by diag(dx,dy,dz) * R' * v\n where v is the velocity of the vehicle expressed in the inertial frame and R' * v = velocity_body_frame\n\n Args:\n state (State): The current state of the vehicle.\n dt (float): The time elapsed between the previous and current function calls (s).\n\n Returns:\n list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference\n \"\"\"\n\n # Get the velocity of the vehicle expressed in the body frame of reference\n body_vel = state.linear_body_velocity\n\n # Compute the component of the drag force to be applied in the body frame\n self._drag_force = -np.dot(self._drag_coefficients, body_vel)\n return self._drag_force\n"},"size":{"kind":"number","value":2762,"string":"2,762"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":42.171874341064466,"string":"42.171874"},"max_line_length":{"kind":"number","value":128,"string":"128"},"alphanum_fraction":{"kind":"number","value":0.6632874726056165,"string":"0.663287"}}},{"rowIdx":86,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/tests/test_hello_world.py"},"content":{"kind":"string","value":"# NOTE:\n# omni.kit.test - std python's unittest module with additional wrapping to add suport for async/await tests\n# For most things refer to unittest docs: https://docs.python.org/3/library/unittest.html\nimport omni.kit.test\n\n# Extnsion for writing UI tests (simulate UI interaction)\nimport omni.kit.ui_test as ui_test\n\n# Import extension python module we are testing with absolute import path, as if we are external user (other extension)\nimport pegasus.simulator\n\n\n# Having a test class dervived from omni.kit.test.AsyncTestCase declared on the root of module will make it auto-discoverable by omni.kit.test\nclass Test(omni.kit.test.AsyncTestCase):\n # Before running each test\n async def setUp(self):\n pass\n\n # After running each test\n async def tearDown(self):\n pass\n\n # Actual test, notice it is \"async\" function, so \"await\" can be used if needed\n async def test_hello_public_function(self):\n result = pegasus.simulator.some_public_function(4)\n self.assertEqual(result, 256)\n\n async def test_window_button(self):\n\n # Find a label in our window\n label = ui_test.find(\"My Window//Frame/**/Label[*]\")\n\n # Find buttons in our window\n add_button = ui_test.find(\"My Window//Frame/**/Button[*].text=='Add'\")\n reset_button = ui_test.find(\"My Window//Frame/**/Button[*].text=='Reset'\")\n\n # Click reset button\n await reset_button.click()\n self.assertEqual(label.widget.text, \"empty\")\n\n await add_button.click()\n self.assertEqual(label.widget.text, \"count: 1\")\n\n await add_button.click()\n self.assertEqual(label.widget.text, \"count: 2\")\n"},"size":{"kind":"number","value":1669,"string":"1,669"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":35.30434705860115,"string":"35.304347"},"max_line_length":{"kind":"number","value":142,"string":"142"},"alphanum_fraction":{"kind":"number","value":0.6830437383564747,"string":"0.683044"}}},{"rowIdx":87,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/config/extension.toml"},"content":{"kind":"string","value":"[package]\n# Semantic Versioning is used: https://semver.org/\nversion = \"1.0.0\"\n\n# Lists people or organizations that are considered the \"authors\" of the package.\nauthors = [\"Marcelo Jacinto\"]\n\n# The title and description fields are primarily for displaying extension info in UI\ntitle = \"Pegasus Simulator\"\ndescription=\"Extension providing the main framework interfaces for simulating aerial vehicles using PX4, Python or ROS 2 as a backend\"\n\n# Path (relative to the root) or content of readme markdown file for UI.\nreadme = \"docs/README.md\"\n\n# URL of the extension source repository.\nrepository = \"\"\n\n# One of categories for UI.\ncategory = \"Simulation\"\n\n# Keywords for the extension\nkeywords = [\"drone\", \"quadrotor\", \"multirotor\", \"UAV\", \"px4\", \"sitl\", \"robotics\"]\n\n# Location of change log file in target (final) folder of extension, relative to the root.\n# More info on writing changelog: https://keepachangelog.com/en/1.0.0/\nchangelog=\"docs/CHANGELOG.md\"\n\n# Preview image and icon. Folder named \"data\" automatically goes in git lfs (see .gitattributes file).\n# Preview image is shown in \"Overview\" of Extensions window. Screenshot of an extension might be a good preview image.\npreview_image = \"data/preview.png\"\n\n# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.\nicon = \"data/icon.png\"\n\n# Use omni.ui to build simple UI\n[dependencies]\n\"omni.ui\" = {}\n\"omni.usd\" = {}\n\"omni.kit.uiapp\" = {}\n\"omni.isaac.core\" = {}\n\"omni.ui.scene\" = {}\n\"omni.kit.window.viewport\" = {}\n\n# Main python module this extension provides, it will be publicly available as \"import pegasus.simulator\".\n[[python.module]]\nname = \"pegasus.simulator\"\n\n[python.pipapi]\nrequirements = [\"numpy\", \"scipy\", \"pymavlink\", \"pyyaml\"]\nuse_online_index = true\n\n[[test]]\n# Extra dependencies only to be used during test run\ndependencies = [\n \"omni.kit.ui_test\" # UI testing extension\n]\n"},"size":{"kind":"number","value":1885,"string":"1,885"},"lang":{"kind":"string","value":"TOML"},"avg_line_length":{"kind":"number","value":32.087718735303184,"string":"32.087719"},"max_line_length":{"kind":"number","value":134,"string":"134"},"alphanum_fraction":{"kind":"number","value":0.7315649863493023,"string":"0.731565"}}},{"rowIdx":88,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/config/configs.yaml"},"content":{"kind":"string","value":"global_coordinates:\n altitude: 90.0\n latitude: 38.736832\n longitude: -9.137977\npx4_dir: ~/PX4-Autopilot\npx4_default_airframe: gazebo-classic_iris # Change to 'iris' if using PX4 version lower than v1.14"},"size":{"kind":"number","value":205,"string":"205"},"lang":{"kind":"string","value":"YAML"},"avg_line_length":{"kind":"number","value":33.333327777778706,"string":"33.333328"},"max_line_length":{"kind":"number","value":98,"string":"98"},"alphanum_fraction":{"kind":"number","value":0.756097557287329,"string":"0.756098"}}},{"rowIdx":89,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/docs/CHANGELOG.md"},"content":{"kind":"string","value":"# Changelog\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).\n\n\n## [1.0.0] - 2023-02-17\n- Initial version of Pegasus Simulator extension\n\n### Added\n- A widget GUI to spawn a limited set of simulation environments and drones using the PX4-bakend.\n- A powerful sensors, drag, thrusters, control and vehicle API.\n- Barometer, IMU, magnetometer and GPS sensors.\n- Linear drag model.\n- Quadratic thrust curve model.\n- Multirotor model.\n- The 3DR Iris quadrotor simulation model.\n- MAVLink communications control support.\n- ROS 2 communications control support (needs fixing).\n- A library for implementing rotations from NED to ENU and FLU to FRD frame conventions.\n- Examples on how to use the framework in standalone scripting mode.\n- Demo with a nonlinear controller implemented in python.\n- A PX4 tool for automatically launching PX4 in SITL mode when provided with the PX4-Autopilot installation directory.\n- A paper describing the motivation for this framework and its inner-workings.\n- Basic documentation generation using sphinx."},"size":{"kind":"number","value":1063,"string":"1,063"},"lang":{"kind":"string","value":"Markdown"},"avg_line_length":{"kind":"number","value":43.33333152777785,"string":"43.333332"},"max_line_length":{"kind":"number","value":118,"string":"118"},"alphanum_fraction":{"kind":"number","value":0.780809030309681,"string":"0.780809"}}},{"rowIdx":90,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/docs/README.md"},"content":{"kind":"string","value":"# Pegasus Simulator\n\nPegasus Simulator is a framework built on top of NVIDIA\nOmniverse and Isaac\nSim. It is designed to provide an easy, yet powerfull way of simulating the dynamics of vehicles. It provides a simulation interface for PX4 integration as well as a custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions.\n\n## Contributing\n\nThe developers of the Pegasus simulator welcome any positive contributions and ideas from the robotics comunity to make\nin order to allow this extension to mature. If you think you have a nice contribution to make or just a simple suggestion,\nfeel free to create bug reports, feature requests or open pull requests for direct code contributions.\n\n## Acknowledgement\n\nNVIDIA Isaac Sim is available freely under https://www.nvidia.com/en-us/omniverse/download/.\n\nPegasus Simulator is released under BSD-3 License.\nThe license files of its dependencies and assets are present in the docs/licenses directory.\n\n## Citation\nPlease cite if you use this extension in your work:\n\n```\n@misc{jacinto2023pegasus,\n\tauthor = {Marcelo Jacinto and Rita Cunha},\n\ttitle = {Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation},\n\tyear = {2023},\n\teprint = {},\n}\n```\n\n## Main Developer Team\n\nThis simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027.\n\n* Project Founder\n\t* Marcelo Jacinto], under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon)\n* Architecture\n * Marcelo Jacinto\n\t* João Pinto\n* Multirotor Dynamic Simulation and Control\n * Marcelo Jacinto\n* Example Applications\n\t* Marcelo Jacinto\n\t* João Pinto\n* Paper Writting and Revision\n\t* Marcelo Jacinto\n\t* João Pinto\n\t* Rita Cunha\n\t* António Pascoal"},"size":{"kind":"number","value":2036,"string":"2,036"},"lang":{"kind":"string","value":"Markdown"},"avg_line_length":{"kind":"number","value":39.739999205200014,"string":"39.739999"},"max_line_length":{"kind":"number","value":324,"string":"324"},"alphanum_fraction":{"kind":"number","value":0.7833988208333011,"string":"0.783399"}}},{"rowIdx":91,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/index.rst"},"content":{"kind":"string","value":"Pegasus Simulator\n#################\n\nOverview\n========\n\n**Pegasus Simulator** is a framework built on top of `NVIDIA\nOmniverse `__ and `Isaac\nSim `__. It is designed to provide an easy yet\npowerful way of simulating the dynamics of multirotors vehicles. It provides a simulation interface for `PX4 `__\nintegration as well as custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions.\n\n.. raw:: html\n\n

\n \n \n

\n\nIf you find ``Pegasus Simulator`` useful in your academic work, please cite the paper below. It is also available `here `_.\n\n.. code-block:: bibtex\n\n @misc{jacinto2023pegasus,\n title={Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation}, \n author={Marcelo Jacinto and João Pinto and Jay Patrikar and John Keller and Rita Cunha and Sebastian Scherer and António Pascoal},\n year={2023},\n eprint={2307.05263},\n archivePrefix={arXiv},\n primaryClass={cs.RO}\n }\n\nDeveloper Team\n~~~~~~~~~~~~~~\n\nThis simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027.\n\n- Project Founder\n - `Marcelo Jacinto `__, under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon)\n- Architecture\n - `Marcelo Jacinto `__\n - `João Pinto `__\n- Multirotor Dynamic Simulation and Control\n - `Marcelo Jacinto `__\n- Example Applications\n - `Marcelo Jacinto `__\n - `João Pinto `__\n\n.. toctree::\n :maxdepth: 2\n :caption: Getting Started\n\n source/setup/installation\n source/setup/developer\n\n.. toctree::\n :maxdepth: 1\n :caption: Tutorials\n\n source/tutorials/run_extension_mode\n source/tutorials/create_standalone_application\n source/tutorials/create_standalone_simulation\n source/tutorials/create_custom_backend\n\n.. toctree::\n :maxdepth: 2\n :caption: Features\n\n source/features/environments\n source/features/vehicles\n source/features/px4_integration\n\n.. toctree::\n :maxdepth: 2\n :caption: Source API\n\n source/api/index\n\n.. toctree::\n :maxdepth: 1\n :caption: References\n\n source/references/contributing\n source/references/known_issues\n source/references/changelog\n source/references/roadmap\n source/references/license\n source/references/bibliography\n\n.. automodule::\"pegasus_isaac\"\n :platform: Linux-x86_64\n :members:\n :undoc-members:\n :show-inheritance:\n :imported-members:\n :exclude-members: contextmanager\n\nOther Simulation Frameworks\n===========================\n\nIn this section, we acknowledge the nobel work of those who came before us and inspired this work:\n\n- :cite:p:`gazebo` Gazebo simulator\n- :cite:p:`rotorS` RotorS simulation plugin for gazebo\n- :cite:p:`px4` PX4-SITL simulation plugin for gazebo\n- :cite:p:`airsim` Microsoft Airsim project for Unreal Engine\n- :cite:p:`flightmare` Flightmare simulator for Unity\n- :cite:p:`jmavsim` jMAVSim java simulator\n\n*\"If I have seen further than others, it is by standing upon the shoulders of giants.\"*, Sir Isaac Newton\n\nProject Sponsors\n================\n\n- Dynamics Systems and Ocean Robotics (DSOR) group of the Institute for Systems and Robotics (ISR), a research unit of the Laboratory of Robotics and Engineering Systems (LARSyS).\n- Instituto Superior Técnico, Universidade de Lisboa\n\nThe work developed by Marcelo Jacinto and João Pinto was supported by Ph.D. grants funded by Fundação para as Ciências e Tecnologias (FCT).\n\n.. raw:: html\n\n

\n \n \n \n \n \n

\n"},"size":{"kind":"number","value":4770,"string":"4,770"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":35.984495845081426,"string":"35.984496"},"max_line_length":{"kind":"number","value":302,"string":"302"},"alphanum_fraction":{"kind":"number","value":0.713417190626118,"string":"0.713417"}}},{"rowIdx":92,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/conf.py"},"content":{"kind":"string","value":"# Configuration file for the Sphinx documentation builder.\n#\n# This file only contains a selection of the most common options. For a full\n# list see the documentation:\n# https://www.sphinx-doc.org/en/master/usage/configuration.html\n\n# -- Path setup --------------------------------------------------------------\n\n# If extensions (or modules to document with autodoc) are in another directory,\n# add these directories to sys.path here. If the directory is relative to the\n# documentation root, use os.path.abspath to make it absolute, like shown here.\n# This section is responsible for auto-generating the API documentation\nimport os\nimport sys\n\nsys.path.insert(0, os.path.abspath(\"../extensions/pegasus.simulator\"))\nsys.path.insert(0, os.path.abspath(\"../extensions/pegasus.simulator/pegasus/simulator\"))\n\n# -- Project information -----------------------------------------------------\n\nproject = \"Pegasus Simulator\"\ncopyright = \"2023, Marcelo Jacinto\"\nauthor = \"Marcelo Jacinto\"\nversion = \"1.0.0\"\n\n# -- General configuration ---------------------------------------------------\n\nextensions = [\n \"sphinx.ext.duration\",\n \"sphinx.ext.doctest\",\n \"sphinx.ext.autodoc\",\n \"autodocsumm\",\n 'sphinx.ext.napoleon',\n #\"sphinx.ext.autosummary\",\n \"sphinx.ext.intersphinx\",\n \"myst_parser\",\n \"sphinx.ext.mathjax\",\n \"sphinxcontrib.bibtex\",\n \"sphinx.ext.todo\",\n \"sphinx.ext.githubpages\",\n \"sphinx.ext.autosectionlabel\",\n \"sphinxcontrib.youtube\",\n \"myst_parser\"\n]\n\nintersphinx_mapping = {\n \"rtd\": (\"https://docs.readthedocs.io/en/stable/\", None),\n \"python\": (\"https://docs.python.org/3/\", None),\n \"sphinx\": (\"https://www.sphinx-doc.org/en/master/\", None),\n}\n\n# mathjax hacks\nmathjax3_config = {\n \"tex\": {\n \"inlineMath\": [[\"\\\\(\", \"\\\\)\"]],\n \"displayMath\": [[\"\\\\[\", \"\\\\]\"]],\n },\n}\n\nintersphinx_disabled_domains = [\"std\"]\n\n# supported file extensions for source files\n#source_suffix = {\n# \".rst\": \"restructuredtext\"\n#}\n\ntemplates_path = [\"_templates\"]\n\nsuppress_warnings = [\"myst.header\", \"autosectionlabel.*\"]\n\n# -- Options for EPUB output\nepub_show_urls = \"footnote\"\n\n# List of patterns, relative to source directory, that match files and\n# directories to ignore when looking for source files.\n# This pattern also affects html_static_path and html_extra_path.\nexclude_patterns = [\"_build\", \"Thumbs.db\", \".DS_Store\", \"README.md\", \"licenses/*\"]\n\n# --- Automatic API documentation generation\n\n# put type hints inside the description instead of the signature (easier to read)\nautodoc_typehints = \"description\"\nautodoc_typehints_description_target = \"documented\"\n# document class *and* __init__ methods\nautoclass_content = \"class\" #\n# separate class docstring from __init__ docstring\nautodoc_class_signature = \"separated\"\n# sort members by source order\nautodoc_member_order = \"groupwise\"\n# default autodoc settings\nautodoc_default_options = {\n \"autosummary\": True,\n}\n\n# BibTeX configuration\nbibtex_bibfiles = [\"bibliography.bib\"]\n\n# Generate documentation for __special__ methods\nnapoleon_include_special_with_doc = True\n\n# Mock out modules that are not available on RTD\nautodoc_mock_imports = [\n \"np\",\n \"torch\",\n \"numpy\",\n \"scipy\",\n \"carb\",\n \"pxr\",\n \"omni\",\n \"omni.kit\",\n \"omni.usd\",\n \"omni.isaac.core.utils.nucleus\",\n \"omni.client\",\n \"pxr.PhysxSchema\",\n \"pxr.PhysicsSchemaTools\",\n \"omni.replicator\",\n \"omni.isaac.core\",\n \"omni.isaac.kit\",\n \"omni.isaac.cloner\",\n \"gym\",\n \"stable_baselines3\",\n \"rsl_rl\",\n \"rl_games\",\n \"ray\",\n \"h5py\",\n \"hid\",\n \"prettytable\",\n \"pyyaml\",\n \"pymavlink\",\n \"rclpy\",\n \"std_msgs\",\n \"sensor_msgs\",\n \"geometry_msgs\"\n]\n\n# -- Options for HTML output -------------------------------------------------\n\n# The theme to use for HTML and HTML Help pages.\nhtml_theme = \"sphinx_rtd_theme\"\n\n# Add any paths that contain custom static files (such as style sheets) here,\n# relative to this directory. They are copied after the builtin static files,\n# so a file named \"default.css\" will overwrite the builtin \"default.css\".\nhtml_static_path = [\"_static\"]\nhtml_logo = \"_static/logo.png\"\nhtml_theme_options = {\n 'logo_only': True,\n 'display_version': False,\n 'style_nav_header_background': '#FFD700'\n}\n\nhtml_show_copyright = True\nhtml_show_sphinx = False\n\n# The master toctree document.\nmaster_doc = \"index\"\n"},"size":{"kind":"number","value":4372,"string":"4,372"},"lang":{"kind":"string","value":"Python"},"avg_line_length":{"kind":"number","value":26.853503013671954,"string":"26.853503"},"max_line_length":{"kind":"number","value":88,"string":"88"},"alphanum_fraction":{"kind":"number","value":0.6450137235487159,"string":"0.645014"}}},{"rowIdx":93,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/licenses/assets/iris-license.rst"},"content":{"kind":"string","value":"| **Author:** Lorenz Meier (lorenz@px4.io) and Thomas Gubler\n| **Description:** The original model has been created by Thomas Gubler. The original model can be found at `PX4 SITL Gazebo `__.\n\n.. code-block:: text \n\n BSD 3-Clause License\n\n Copyright (c) 2012 - 2023, PX4 Development Team\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n * Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n * Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n * Neither the name of the copyright holder nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},"size":{"kind":"number","value":1836,"string":"1,836"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":53.02941020501735,"string":"53.02941"},"max_line_length":{"kind":"number","value":178,"string":"178"},"alphanum_fraction":{"kind":"number","value":0.7766884527360084,"string":"0.776688"}}},{"rowIdx":94,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_standalone_application.rst"},"content":{"kind":"string","value":"Create a Standalone Application\n===============================\n\nThis tutorial introduces how to create a standalone python script to set up an empty scene.\nIt introduces the main class used by ``Isaac Sim`` simulator, :class:`SimulationApp`, as well as the :class:`timeline`\nconcept that helps to launch and control the simulation timeline. In this tutorial we do **NOT** expose the \n``Pegasus API`` yet.\n\n1. Code\n-------\n\nThe tutorial corresponds to the ``0_template_app.py`` example in the ``examples`` directory.\n\n\n.. literalinclude:: ../../../examples/0_template_app.py\n :language: python\n :emphasize-lines: 11-16,35-54,85-102\n :linenos:\n\n2. Explanation\n--------------\n\nThe first step, when creating a ``standalone application`` with ``Isaac Sim`` is to instantiate the :class:`SimulationApp`\nobject, and it takes a dictionary of parameters that can be used to configure the application. This \nobject will be responsible for opening a ``bare bones`` version of the simulator. The ``headless`` parameter\nselects whether to launch the GUI window or not.\n\n\n.. literalinclude:: ../../../examples/0_template_app.py\n :language: python\n :lines: 11-16\n :linenos:\n :lineno-start: 11\n\n.. note::\n \n You can **NOT** import other omniverse modules before instantiating the :class:`SimulationApp`, otherwise the simulation crashes\n before the window it's even open. For a deeper understanding on how the :class:`SimulationApp` works, check \n `NVIDIA's offical documentation `__.\n\nIn order to create a `Simulation Context `__,\nwe resort to the `World `__ class environment. The `World `__ class inherits the `Simulation Context `__,\nand provides already some default parameters for setting up a simulation for us. You can pass as arguments the physics \ntime step and rendering time step (in seconds). The rendering and physics can be set to run at different rates. For now let's use the defaults: 60Hz for both rendering and physics.\n\nAfter creating the `World `__ class environment. The `World `__ class inherits the `Simulation Context `__, we will\ntake advantage of its ``callback system`` to declare that some functions defined by us should be called at every physics iteration, \nrender iteration or every time there is a timeline event, such as pressing the start/stop button. In this case, the\n``physics_callback`` method will be invoked at every physics step, the ``render_callback`` at every render step and \n``timeline_callback`` every time there is a timeline event. You can add as many callbacks as you want. After having all your\ncallbacks defined, the ``world.reset()`` method should be invoked to initialize the ``physics context`` and set any existing\nrobot joints (in this case there is none) to their default state.\n\n.. literalinclude:: ../../../examples/0_template_app.py\n :language: python\n :lines: 35-54\n :linenos:\n :lineno-start: 35\n\nTo start the actual simulation, we invoke the timeline's ``play()`` method. This is necessary in order to ensure that \nevery previously defined callback gets invoked. In order for the ``Isaac Sim`` app to remain responsive, we need to create\na ``while loop`` that invokes ``world.step(render=True)`` to make sure that the UI get's rendered.\n\n.. literalinclude:: ../../../examples/0_template_app.py\n :language: python\n :lines: 85-102\n :linenos:\n :lineno-start: 85\n\nAs you may have noticed, our ``infinite loop`` is very clean. In this work, similarly to the ROS 2 standard,\nwe prefer to perform all the logic by resorting to function callbacks instead of cramming all the logic inside \nthe while loop. This structure allows our code to be more organized and more modular. As you will learn in the following\ntutorials, the ``Pegasus Simulator API`` is built on top of this idea of ``callbacks``.\n\n3. Execution\n------------\n\nNow let's run the Python script:\n\n.. code:: bash\n\n ISAACSIM_PYTHON examples/0_template_app.py\n\nThis should open a stage with a blue ground-plane. The simulation should start playing automatically and the stage being rendered. \nTo stop the simulation, you can either ``close the window``, press the ``STOP button`` in the UI, or press ``Ctrl+C`` in the terminal.\n\n.. note:: \n\n Notice that the window will only close when pressing the ``STOP button``, because we defined a method called \n ``timeline_callback`` that get's invoked for every ``timeline event``, such as pressing the ``STOP button``. "},"size":{"kind":"number","value":5524,"string":"5,524"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":60.38888821790125,"string":"60.388888"},"max_line_length":{"kind":"number","value":537,"string":"537"},"alphanum_fraction":{"kind":"number","value":0.7501810281046015,"string":"0.750181"}}},{"rowIdx":95,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_standalone_simulation.rst"},"content":{"kind":"string","value":"Your First Simulation\n=====================\n\nIn this tutorial, you will create a standalone Python application to perform a simulation using 1 vehicle and ``PX4-Autopilot``. \nThe end result should be the equivalent to the :ref:`Run in Extension Mode (GUI)` tutorial. To achieve this, we will cover the\nbasics of the Pegasus Simulator :ref:`API Reference`.\n\n0. Preparation\n--------------\nBefore you proceed, make sure you have read the :ref:`Installing the Pegasus Simulator` section first and that your system\nis correctly configured. Also, we will assume that you already followed the :ref:`Create a Standalone Application` tutorial, as in this tutorial\nwe will resort to concepts introduced in it.\n\nAdditionally, you will also be required to have ``QGroundControl`` installed to operate the simulated vehicle. If you haven't\nalready, follow the Preparation section in the :ref:`Run in Extension Mode (GUI)` tutorial.\n\n\n1. Code\n--------\n\nThe tutorial corresponds to the ``1_px4_single_vehicle.py`` example in the ``examples`` directory.\n\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :emphasize-lines: 24-29,47-48,55-56,58-77,79-80\n :linenos:\n\n2. Explanation\n---------------\n\nIn order to start using the functionalities provided by the ``Pegasus Simulator``, we import some of the most commonly\nused classes from the ``pegasus.simulator.logic`` module, which contains all the core APIs. To check all the classes and \nmethods currently provided, please refer to the :ref:`API Reference` section.\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :lines: 24-29\n :linenos:\n :lineno-start: 24\n\n.. note::\n\n Some APIs may not be documented in the :ref:`API Reference` section. This means one of three things:\n i) they are not meant for public use; ii) under development (untested); iii) or just deprecated and about to be replaced.\n\nNext, we initialize the :class:`PegasusInterface` object. This is a singleton, which means that there exists only one \n:class:`PegasusInterface` in memory at any time. This interface creates a `World `__ class environment. The `World `__ class inherits the `Simulation Context `__\ninternally, so you do not need to declare your own manually when using this API. By default, when physics engine is set to run\nat ``250 Hz`` and the render engine at ``60Hz``.\n\nThe :class:`PegasusInterface` provides methods to set the simulation environment, define the geographic coordinates of the origin of the world, setting the default path for the PX4-Autopilot installation and much more. To learn more about this class, refer to the :ref:`Pegasus Interface` API section.\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :lines: 47-48\n :linenos:\n :lineno-start: 47\n\nNext, we load the 3D world environment. For this purpose, we provide the auxiliary method ``load_environment(usd_file)`` for\nloading pre-made environments stored in `Universal Scene Description (.usd) `__ files. In this\nexample, we load one of the simulation environments already provided by NVIDIA, whose path in stored in the ``SIMULATION_ENVIRONMENTS``\ndictionary. To known all provided environments, check the :ref:`Params` API section.\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :lines: 55-56\n :linenos:\n :lineno-start: 55\n\nThe next step is to create a multirotor vehicle object. For that we start by creating a ``MultirotorConfig``, which contains \nby default a :class:`QuadraticThrustCurve`, :class:`Linear Drag` model, a list of ``Sensors`` composed of a :class:`GPS`, \n:class:`IMU`, :class:`Magnetometer` and :class:`Barometer`, and a list of control :class:`Backend`.\n\nIn this tutorial, we whish to control the vehicle via ``MAVLink``, ``PX4-Autopilot`` and ``QGroundControl``. Therefore,\nwe create a ``MAVLink`` control backend configured to also launch ``PX4-Autopilot`` in SITL mode in the background.\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :lines: 58-68\n :linenos:\n :lineno-start: 58\n\nTo create the actual ``Multirotor`` object, we must specify the ``stage_path``, i.e. the name that the vehicle will have inside\nthe simulation tree and the ``usd_path`` which defines where the 3D model of the vehicle is stored. Once again, to known all \nprovided vehicle models, check the :ref:`Params` API section. Additionally, we can provide the original position and orientation\nof the vehicle, according to an East-North-DOWN (ENU) convention.\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :lines: 70-77\n :linenos:\n :lineno-start: 70\n\nAfter the simulation is setup, the ``world.reset()`` method should be invoked to initialize the ``physics context`` and set any existing\nrobot joints (the multirotor rotor joints) to their default state.\n\n.. literalinclude:: ../../../examples/1_px4_single_vehicle.py\n :language: python\n :lines: 79-80\n :linenos:\n :lineno-start: 79\n\n\n3. Execution\n------------\n\nNow let's run the Python script:\n\n.. code:: bash\n\n ISAACSIM_PYTHON examples/1_px4_single_vehicle.py\n\nThis should open a stage with a blue ground-plane with an 3DR Iris vehicle model in it. The simulation should start playing automatically and the stage being rendered. \nPX4-Autopilot will start running automatically in the background, receiving data from the simulated sensors and sending\ntarget angular velocities for the vehicle rotors. You can now play with the vehicle using ``QGroundControl`` similarly to \nwhat was shown in :ref:`Run in Extension Mode (GUI)` tutorial.\n\nTo stop the simulation, you can either ``close the window``, press the ``STOP button`` in the UI, or press ``Ctrl+C`` in the terminal.\n"},"size":{"kind":"number","value":6234,"string":"6,234"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":50.95833290868056,"string":"50.958333"},"max_line_length":{"kind":"number","value":583,"string":"583"},"alphanum_fraction":{"kind":"number","value":0.7428617258994447,"string":"0.742862"}}},{"rowIdx":96,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_custom_backend.rst"},"content":{"kind":"string","value":"Create a Custom Controller\n==========================\n\nIn this tutorial, you will learn how to create a custom ``control backend`` that receives the current state of the vehicle and\nits sensors and computes the control inputs to give to the rotors of the drone. The control laws implemented in this tutorial\nand the math behind them are well described in :cite:p:`Pinto2021`, :cite:p:`mellinger_kumar`.\n\nIn this tutorial we will endup with a simulation that does **NOT** use ``PX4-Autopilot`` , and instead will use a custom nonlinear\ncontroller to make the vehicle follow a pre-determined trajectory, written in just a few lines of pure Python code.\n\n.. note::\n\n The Control Backend API is what was used to implement the MAVLink/PX4 backend. This interface is very powerful as it not only allows\n the user to create custom communication protocols (such as ROS) for controlling the vehicle, as well as defining and testing new\n control algorithms directly in pure Python code. This is specially usefull for conducting MATLAB-like simulations,\n as we can implement and test algorithms directly in a 3D environment by writing a few lines of Python code without having to deal\n with `Mavlink`, `PX4` or `ROS` like in other simulators.\n\n0. Preparation\n--------------\n\nThis tutorial assumes that you have followed the :ref:`Your First Simulation` section first.\n\n1. Code\n-------\n\nThe tutorial corresponds to the ``4_python_single_vehicle.py`` example in the ``examples`` directory.\n\n.. literalinclude:: ../../../examples/4_python_single_vehicle.py\n :language: python\n :emphasize-lines: 30-31,68-75\n :linenos:\n\nThe next code section corresponds to the ``nonlinear_controller.py`` in the ``examples/utils`` directory.\n\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :emphasize-lines: 18,24-44,114-117,121-124,143-151,154-160,168-174,177-183\n :linenos:\n\n2. Explanation\n--------------\n\nTo start a pre-programed simulation using a different control backend other than ``MAVLink`` we include our custom \n``control backend`` module written in pure Python. \n\n.. literalinclude:: ../../../examples/4_python_single_vehicle.py\n :language: python\n :lines: 30-31\n :linenos:\n :lineno-start: 30\n\nWe now create a multirotor configuration and set the multirotor backend to be our ``NonlinearController`` object. That's it! \nIt is that simple! Instead of using the `MAVLink/PX4`` control we will use a pure Python controller written by us. The rest \nof the script is the same as in the previous tutorial. \n\n.. literalinclude:: ../../../examples/4_python_single_vehicle.py\n :language: python\n :lines: 68-75\n :linenos:\n :lineno-start: 68\n\nNow, let's take a look on how the ``NonlinearControl`` class is structured and how you can build your own. We must start by\nincluding the ``Backend`` class found in the ``pegasus.simulator.logic.backends`` API. To explore all the functionalities\noffered by this class, check the :ref:`Backend` API reference page.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 18\n :linenos:\n :lineno-start: 18\n\nNext, we define a class that inherits the `Backend`` class. This class must implement a few methods to be compliant\nwith the ``Multirotor`` API. In this example we will implement an \"hard-coded\" nonlinear geometrical controller for the\nmultirotor to track a pre-defined trajectory.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 24-44\n :linenos:\n :lineno-start: 24\n\nThe first method that should be implemented is ``start()`` . This method gets invoked by\nthe vehicle when the simulation starts. You should perform any initialization of your algorithm or communication protocol\nhere.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 114-117\n :linenos:\n :lineno-start: 114\n\nThe ``stop()`` method gets invoked by\nthe vehicle when the simulation stops. You should perform any cleanup here.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 121-124\n :linenos:\n :lineno-start: 121\n\nThe ``update_sensor(sensor_type: str, data)`` method gets invoked by the vehicle at every physics step iteration (it is used as a callback) for \neach sensor that generated output data. It receives as input a string which describes the type of sensor and the data produced by that sensor.\nIt is up to you to decide on how to parse the sensor data and use it. In this case we are not going to use the data produced\nby the simulated sensors for our controller. Instead we will get the state of the vehicle directly from the simulation and \nuse that to feedback into our control law.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 143-151\n :linenos:\n :lineno-start: 143\n\n.. note::\n\n You can take a look on how the ``MavlinkBackend`` is implemented to check on how to parse sensor data produced by IMU, GPS, etc. \n A simple strategy is to use an if-statement to check for which sensor we are receive the data from and parse it accordingly, for example:\n\n .. code:: Python\n\n if sensor_type == \"imu\":\n # do something\n elif sensor_type == \"gps\":\n # do something else\n else:\n # some sensor we do not care about, so ignore\n\n Check the Sensors :ref:`API Reference` to check what type of data each sensor generates. For most cases, it will be a dictionary.\n\nThe ``update_state(state: State)`` method is called at every physics steps with the most up-to-date ``State`` of the vehicle. The state\nobject contains:\n\n- **position** of the vehicle's body frame with respect to the inertial frame, expressed in the inertial frame;\n- **attitude** of the vehicle's body frame with respect to the inertial frame, expressed in the inertial frame;\n- **linear velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the inertial frame;\n- **linear body-velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the vehicle's body frame;\n- **angular velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the vehicle's body frame;\n- **linear acceleration** of the vehicle's body frame, with respect to the inertial frame, expressed in the inertial frame.\n\nAll of this data is filled adopting a **East-North-Down (ENU)** convention for the Inertial Reference Frame and a **Front-Left-Up (FLU)** \nfor the vehicle's body frame of reference. \n\n.. note::\n\n In case you need to adopt other conventions, the ``State`` class also provides methods to return the state of the vehicle in\n North-East-Down (NED) and Front-Right-Down (FRD) conventions, so you don't have to make those conversions manually. Check\n the :ref:`State` API reference page for more information.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 154-160\n :linenos:\n :lineno-start: 154\n\nThe ``input_reference()`` method is called at every physics steps by the vehicle to retrieve from the controller a list of floats \nwith the target angular velocities in [rad/s] to use as reference to apply to each vehicle rotor. The list of floats\nreturned by this method should have the same length as the number of rotors of the vehicle.\n\n.. note::\n\n In order to have a general controller, you might not want to hard-code the number of rotors of the vehicle in the controller.\n To take this into account, the :ref:`Backend` object is initialized with a reference to the :ref:`Vehicle` object\n when this gets instantiated. Therefore, it will access to all of its attributes, such as the number of rotors and methods\n to convert torques and forces in the body-frame to target rotor angular velocities!\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 168-174\n :linenos:\n :lineno-start: 168\n\n\nThe ``update(dt: float)`` method gets invoked at every physics step by the vehicle. It receives as argument the amount of time\nelapsed since the last update (in seconds). This is where you should define your controller/communication layer logic and \nupdate the list of reference angular velocities for the rotors.\n\n.. literalinclude:: ../../../examples/utils/nonlinear_controller.py\n :language: python\n :lines: 177-183\n :linenos:\n :lineno-start: 177\n\n3. Execution\n------------\n\nNow let's run the Python script:\n\n.. code:: bash\n\n ISAACSIM_PYTHON examples/4_python_single_vehicle.py\n\nThis should open a stage with a blue ground-plane with an 3DR Iris vehicle model in it. The simulation should start playing automatically and the stage being rendered. \nThe vehicle will automatically start flying and performing a very fast relay maneuvre. If you miss it, you can just hit the stop/play\nbutton again to repeat it. \n\nNotice now, that unlike the previous tutorial, if you open ``QGroundControl`` you won't see the vehicle. This is normal, because\nnow we are not using the ``MAVLink`` control backend, but instead our custom ``NonlinearControl`` backend."},"size":{"kind":"number","value":9195,"string":"9,195"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":45.44444421492705,"string":"45.444444"},"max_line_length":{"kind":"number","value":168,"string":"168"},"alphanum_fraction":{"kind":"number","value":0.7375747688159244,"string":"0.737575"}}},{"rowIdx":97,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/source/tutorials/run_extension_mode.rst"},"content":{"kind":"string","value":"Run in Extension Mode (GUI)\n=======================================\n\nThis tutorial introduces how to interface with the Pegasus Simulator working in extension mode, i.e. with an interactive GUI. \nThis means that ``ISAACSIM`` will be launched as a standard application and the Pegasus Simulator extension should be \nenabled from the extension manager.\n\n0. Preparation\n--------------\n\nBefore you proceed, check the :ref:`Installing the Pegasus Simulator` section first, if you haven't already. You will\nalso require `QGroundControl `__ to control the vehicle. You haven't download it yet, you can\ndo it `here `__ or follow these steps:\n\n1. Open a new terminal and run:\n\n .. code:: bash\n\n sudo usermod -a -G dialout $USER\n sudo apt-get remove modemmanager -y\n sudo apt install gstreamer1.0-plugins-bad gstreamer1.0-libav gstreamer1.0-gl -y\n sudo apt install libqt5gui5 -y\n sudo apt install libfuse2 -y\n\n2. Download the `QGroundControl App Image `__.\n\n3. Make the App image executable\n\n .. code:: bash\n\n chmod +x ./QGroundControl.AppImage\n\n4. Execute QGroundControl by double-clicking or running:\n\n .. code:: bash\n\n ./QGroundControl.AppImage\n\n1. Simulation Steps\n-------------------\n\n1. Open ``ISAACSIM``, either by using the Omniverse Launcher or the terminal command:\n\n .. code:: bash\n\n ISAACSIM\n\n2. Make sure the Pegasus Simulator Extension is enabled.\n\n .. image:: /_static/pegasus_inside_extensions_menu.png\n :width: 600px\n :align: center\n :alt: Enable the Pegasus Simulator extension inside Isaac Sim\n\n3. On the Pegasus Simulator tab in the bottom-right corner, click on the ``Load Scene`` button.\n\n .. image:: /_static/tutorials/load_scene.png\n :width: 600px\n :align: center\n :alt: Load a 3D Scene\n\n4. Again, on the Pegasus Simulator tab, click on the ``Load Vehicle`` button.\n\n .. image:: /_static/tutorials/load_vehicle.png\n :width: 600px\n :align: center\n :alt: Load the vehicle\n\n5. Press the ``play`` button on the simulator's control bar on the left corner.\n\n .. image:: /_static/tutorials/play.png\n :width: 600px\n :align: center\n :alt: Start the simulation environment\n\n6. On QGroundControl, an arrow representing the vehicle should pop-up. You can now perform a take-off, but pressing the\n``take-off`` button on top-left corner of QGroundControl.\n\n .. image:: /_static/tutorials/take_off.png\n :width: 600px\n :align: center\n :alt: Perform a take-off with the drone\n\n7. On QGroundControl, left-click on a place on the map, press ``Go to location`` and slide at the bottom of the screen\nto confirm the target waypoint for the drone to follow.\n\n .. image:: /_static/tutorials/go_to_location.png\n :width: 600px\n :align: center\n :alt: Perform a go-to waypoint with the drone\n\nCongratulations 🎉️🎉️🎉️ ! You have just completed your first tutorial and you should now see the vehicle moving on the screen.\n\nA short video of this tutorial is also available `here `__.\n\n .. youtube:: _11OCFwf_GE\n :width: 100%\n :align: center\n :privacy_mode:\n\n.. note::\n\n Everything that you can do using the provided GUI can also be achieved by the Pegasus Simulator API in Python. In the next\n tutorials we will cover how to create standalone Python scripts to perform simulations."},"size":{"kind":"number","value":3619,"string":"3,619"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":33.807691982618344,"string":"33.807692"},"max_line_length":{"kind":"number","value":126,"string":"126"},"alphanum_fraction":{"kind":"number","value":0.6822326607675511,"string":"0.682233"}}},{"rowIdx":98,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/source/setup/installation.rst"},"content":{"kind":"string","value":"Installation\n============\n\nInstalling NVIDIA Isaac Sim\n---------------------------\n\n.. image:: https://img.shields.io/badge/IsaacSim-2023.1.1-brightgreen.svg\n :target: https://developer.nvidia.com/isaac-sim\n :alt: IsaacSim 2023.1.1\n\n.. image:: https://img.shields.io/badge/PX4--Autopilot-1.14.1-brightgreen.svg\n :target: https://github.com/PX4/PX4-Autopilot\n :alt: PX4-Autopilot 1.14.1\n\n.. image:: https://img.shields.io/badge/Ubuntu-22.04LTS-brightgreen.svg\n :target: https://releases.ubuntu.com/22.04/\n :alt: Ubuntu 22.04\n\n.. note::\n\tWe have tested Pegasus Simulator with Isaac Sim 2023.1.1 release on Ubuntu 22.04LTS with NVIDIA driver 545.23.08. The PX4-Autopilot used during development was v.14.1. Older versions Ubuntu and PX4-Autopilot were not tested. This extension was not tested on Windows. \n\nIn order to install Isaac Sim on linux, download the `Omniverse AppImage here `__ or run the following line on the terminal:\n\n.. code:: bash\n\n wget https://install.launcher.omniverse.nvidia.com/installers/omniverse-launcher-linux.AppImage\n\n\nA short video with the installation guide for Pegasus Simulator is also available `here `__.\n\n .. youtube:: YCp5E8nazag\n :width: 100%\n :align: center\n :privacy_mode:\n\n\nConfiguring the environment variables\n-------------------------------------\n\nNVIDIA provides Isaac Sim with its own Python interpreter along with some basic extensions such as numpy and pytorch. In\norder for the Pegasus Simulator to work, we require the user to use the same python environment when starting a simulation\nfrom python scripts. As such, we recommend setting up a few custom environment variables to make this process simpler.\n\n.. note::\n Although it is possible to setup a virtual environment following the \n instructions `here `__, this\n feature was not tested.\n\nStart by locating the `Isaac Sim installation `__ \nby navigating to Isaac Sim's root folder. Typically, in Linux, this folder can be found under ``${HOME}/.local/share/ov/pkg/isaac_sim-*``,\nwhere the ``*`` is the version number.\n\nAdd the following lines to your ``~/.bashrc`` or ``~/.zshrc`` file.\n\n.. code:: bash\n\n # Isaac Sim root directory\n export ISAACSIM_PATH=\"${HOME}/.local/share/ov/pkg/isaac_sim-*\"\n # Isaac Sim python executable\n alias ISAACSIM_PYTHON=\"${ISAACSIM_PATH}/python.sh\"\n # Isaac Sim app\n alias ISAACSIM=\"${ISAACSIM_PATH}/isaac-sim.sh\"\n\nIf you only have one version of Isaac Sim installed, you can leave the ``*``, otherwise you will have to replace it by the \nversion that you desire to use. In the remaining of the documentation, we will refer to the Isaac Sim's path as ``ISAACSIM_PATH`` ,\nthe provided python interpreter as ``ISAACSIM_PYTHON`` and the simulator itself as ``ISAACSIM`` .\n\nRunning Isaac Sim\n~~~~~~~~~~~~~~~~~\n\nAt this point, you are expected to have NVIDIA Isaac Sim fully installed and working. To make sure you have everything setup correctly,\nopen a new terminal window (**Ctrl+Alt+T**), and test the following commands:\n\n- Check that the simulator app can be launched\n\n .. code:: bash\n\n # Run the simulator with the --help argument to see all available options\n ISAACSIM --help\n\n # Run the simulator. A new window should open\n ISAACSIM\n\n- Check that you can launch the simulator from a python script (standalone mode)\n\n .. code:: bash\n\n # Run the bundled python interpreter and see if it prints on the terminal \"Hello World.\"\n ISAACSIM_PYTHON -c \"print('Hello World.')\"\n\n # Run the python interpreter and check if we can run a script that starts the simulator and adds cubes to the world\n ISAACSIM_PYTHON ${ISAACSIM_PATH}/standalone_examples/api/omni.isaac.core/add_cubes.py\n\nIf you were unable to run the commands above successfuly, then something is incorrectly configured. \nPlease do not proceed with this installation until you have everything setup correctly.\n\nAddtional Isaac Sim resources:\n- `Troubleshooting documentation `__\n\nInstalling the Pegasus Simulator\n--------------------------------\n\nClone the `Pegasus Simulator `__:\n\n.. code:: bash\n\n # Option 1: With HTTPS\n git clone https://github.com/PegasusSimulator/PegasusSimulator.git\n # Option 2: With SSH (you need to setup a github account with ssh keys)\n git clone git@github.com:PegasusSimulator/PegasusSimulator.git\n \n\nThe Pegasus Simulator was originally developed as an Isaac Sim extension with an interactive GUI, but also provides a powerfull\nAPI that allows it to run as a standalone app, i.e. by creating python scritps (as shown in the examples directory of this repository).\nTo be able to use the extension in both modes, follow these steps:\n\n1. Launch ``ISAACSIM`` application.\n\n2. Open the Window->extensions on the top menubar inside Isaac Sim.\n\n .. image:: /_static/extensions_menu_bar.png\n :width: 600px\n :align: center\n :alt: Extensions on top menubar\n\n3. On the Extensions manager menu, we can enable or disable extensions. By pressing the settings button, we can \nadd a path to the Pegasus-Simulator repository.\n\n .. image:: /_static/extensions_widget.png\n :width: 600px\n :align: center\n :alt: Extensions widget\n\n4. The path inserted should be the path to the repository followed by ``/extensions``.\n\n .. image:: /_static/ading_extension_path.png\n :width: 600px\n :align: center\n :alt: Adding extension path to the extension manager\n\n5. After adding the path to the extension, we can enable the Pegasus Simulator extension on the third-party tab.\n\n .. image:: /_static/pegasus_inside_extensions_menu.png\n :width: 600px\n :align: center\n :alt: Pegasus Extension on the third-party tab\n\nWhen enabling the extension for the first time, the python requirements should be install automatically for the build in \n``ISAACSIM_PYTHON`` , and after a few seconds, the Pegasus widget GUI should pop-up.\n\n6. The Pegasus Simulator window should appear docked to the bottom-right section of the screen.\n\n .. image:: /_static/pegasus_gui_example.png\n :width: 600px\n :align: center\n :alt: Pegasus Extension GUI after install\n\nInstalling the extension as a library\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIn order to be able to use the Pegasus Simulator API from python scripts and standalone apps, we must install this \nextension as a ``pip`` python module for the built-in ``ISAACSIM_PYTHON`` to recognize. For that, run:\n\n.. code:: bash\n\n # Go to the repository of the pegasus simulator\n cd PegasusSimulator\n\n # Go into the extensions directory\n cd extensions\n\n # Run the pip command using the built-in python interpreter\n ISAACSIM_PYTHON -m pip install --editable pegasus.simulator\n\nWe use the ``--editable`` flag so that the content of the extension is linked instead of copied. After this step, you \nshould be able to run the python standalone examples inside the ``examples`` folder.\n\nInstalling PX4-Autopilot\n------------------------\n\nIn this first version of the Pegasus Simulator (in extension mode), the GUI widget provided is only usefull if you intend to use the PX4-Autopilot.\nTo install PX4-Autopilot, follow the following steps:\n\n1. Install the dependencies (to be able to compile PX4-Autopilot):\n\n .. code:: bash\n\n # Linux packages\n sudo apt install git make cmake python3-pip\n \n # Python packages\n pip install kconfiglib jinja2 empy jsonschema pyros-genmsg packaging toml numpy future\n\n2. Clone the `PX4-Autopilot `__:\n\n .. code:: bash\n\n # Option 1: With HTTPS\n git clone https://github.com/PX4/PX4-Autopilot.git\n # Option 2: With SSH (you need to setup a github account with ssh keys)\n git clone git@github.com:PX4/PX4-Autopilot.git\n\n3. Checkout to the stable version 1.14.1 and compile the code for software-in-the-loop (SITL) mode:\n\n .. code:: bash\n \n # Go to the PX4 directory\n cd PX4-Autopilot\n\n # Checkout to the latest stable release\n git checkout v1.14.1\n\n # Initiate all the submodules. Note this will download modules such as SITL-gazebo which we do not need\n # but this is the safest way to make sure that the PX4-Autopilot and its submodules are all checked out in \n # a stable and well tested release\n git submodule update --init --recursive\n\n # Compile the code in SITL mode\n make px4_sitl_default none\n\nNote: If you are installing a version of PX4 prior to v1.14.1, you may need to go to change the default airframe to \nbe used by PX4. This can be achieved by:\n\n .. code:: bash\n \n # Go inside the config folder of the pegasus simulator extension\n cd PegasusSimulator/extensions/pegasus/simulator/config\n\n # Open the file configs.yaml\n nano configs.yaml\n\n # And change the line:\n px4_default_airframe: iris\n\nYou can also set the PX4 installation path inside the Pegasus Simulator GUI, as shown in the next section, or by editing\nthe file ``PegasusSimulator/extensions/pegasus/simulator/config/config.yaml`` and setting the ``px4_dir`` field to the correct path.\n\nSetting the PX4 path inside the Pegasus Simulator\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe simulator provides a feature to auto-launch PX4-Autopilot for every vehicle that is spawned in the simulation world. \nFor this feature to work, we need to tell the Pegasus Simulator extension where the PX4-Autopilot directory can be found. \nFor that, edit the ``PX4 Path`` text field if is not correct by default and press the ``Make Default`` button. This \nfield supports relative paths to the home directory, which means that you can use ``~`` to represent the home directory \nwithout hard-coding it.\n\n.. image:: /_static/pegasus_GUI_px4_dir.png\n :width: 600px\n :align: center\n :alt: Pegasus GUI with px4 directory highlighted\n\nBy default, the extension assumes that PX4-Autopilot is installed at ``~/PX4-Autopilot`` .\n"},"size":{"kind":"number","value":10494,"string":"10,494"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":40.48221327872643,"string":"40.482213"},"max_line_length":{"kind":"number","value":268,"string":"268"},"alphanum_fraction":{"kind":"number","value":0.7086906803212606,"string":"0.708691"}}},{"rowIdx":99,"cells":{"file_path":{"kind":"string","value":"PegasusSimulator/PegasusSimulator/docs/source/setup/developer.rst"},"content":{"kind":"string","value":"Development\n===========\n\nWe developed this extension using `Visual Studio Code `__, the \nrecommended tool on NVIDIA's Omniverse official documentation. To setup Visual Studio Code with hot-reloading features, follow\nthe additional documentation pages:\n\n* `Isaac Sim VSCode support `__\n* `Debugging with VSCode `__\n\nTo enable a better developer experience when contributing or modifying this extension, and have access to features such as\nautocomplete, we recommend linking the Pegasus Simulator repository to the current installation of ``ISAACSIM`` . For that, please\nrun the following script provided with the framework:\n\n.. code:: bash\n\n ./link_app.sh --path $ISAACSIM_PATH\n\nThis script will create a symbolic link to ``ISAACSIM`` inside the repository. After this step, you can also launch the \n``ISAACSIM`` with the extension enabled (without using the GUI presented in Section :ref:`Installing the Pegasus Simulator`), by running:\n\n.. code:: bash\n\n ./app/isaac-sim.sh --ext-folder extensions --enable pegasus.simulator\n\nCode structure\n--------------\n\nThis simulation framework is strucuture according to the following tree:\n\n.. code:: bash\n\n PegasusSimulator:\n ├── .vscode\n ├── docs\n ├── examples\n ├── tools\n ├── extensions\n │   ├── pegasus.simulator\n │   │   ├── config\n │   │   ├── data\n │   │   ├── docs\n │   │   ├── setup.py\n │   │   ├── pegasus.simulator\n │   │   │   │   ├── __init__.py\n │   │   │   │   ├── params.py\n │   │   │   │   ├── extension.py\n │   │   │   │   ├── assets\n │   │   │   │   ├── logic\n │   │   │   │   ├── ui\n\nThe extensions directory contains the source code for the PegasusSimulator API and interactive GUI while the \nexamples directory contains the a set of python scripts to launch standalone applications and pre-programed simulations.\n\nAs explained in NVIDIA's documentation, extensions are the standard way of developing on top of Isaac Sim and other Omniverse\ntools. The core of our extension is developed in the ``logic`` and the ``ui`` modules. The ``logic`` API is exposed to the users\nand is used both when operating the Pegasus Simulator in GUI widget/extension mode and via standalone python applications.\nThe ``ui`` API is **not exposed/documented** as it is basically defines the widget to call functionalities provided by \nthe ``logic`` module.\n"},"size":{"kind":"number","value":2604,"string":"2,604"},"lang":{"kind":"string","value":"reStructuredText"},"avg_line_length":{"kind":"number","value":42.41666595972224,"string":"42.416666"},"max_line_length":{"kind":"number","value":146,"string":"146"},"alphanum_fraction":{"kind":"number","value":0.697004608027264,"string":"0.697005"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":19287,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc2MjMxNDc5Mywic3ViIjoiL2RhdGFzZXRzL3BlLW5scC9vdi1raXQtY29kZS1maWxlcy12My1maWx0ZXJlZC1kZWR1cCIsImV4cCI6MTc2MjMxODM5MywiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.ESBfbBmYZFMrKuZq6ZQ3WczNv5e53qt5LqOh_tV_JT1KqmOFH9d1ch2WpH1o3cl6jQGK5wj1uVCO2CSa9gjVCw","displayUrls":true,"sqlConsoleEnabled":true},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">

Datasets:

---

pe-nlp

/

ov-kit-code-files-v3-filtered-dedup

like 0

Follow

PE-NLP 22

Dataset card Data Studio Files Files and versions

xet

Community

Subset (1)

default · 19.3k rows

default (19.3k rows)

Split (1)

train · 19.3k rows

train (19.3k rows)

SQL

Console

file_path stringlengths 20 202	content stringlengths 9 3.85M	size int64 9 3.85M	lang stringclasses 9 values	avg_line_length float64 3.33 100	max_line_length int64 8 993	alphanum_fraction float64 0.26 0.93
ashleygoldstein/LWM-Warehouse-Scene/README.md	# LWM-Warehouse-Scene This Sample was developed during the Learn With Me livestream Series. Learn With Me streams every Monday and Wednesday at 1pm EST on the NVIDIA Omniverse Twitch and YouTube channels https://www.youtube.com/@NVIDIAOmniverse/streams Playlist of the previously recorded streams: https://youtube.com/playlist?list=PLPR2h_elPvVKH9HLtdgfXNUxGeN6QAlc7 This USD works in Omniverse USD Composer (fka Create) and Isaac Sim 2022.2.0 and later versions. Check out the Tests folder for simple test scenes. Contributors/Inspired Authors: Alberto Arenas / Omniverse Ambassador- Camera Constraint ActionGraph Mathew Schwartz / NJIT - Behavior Scripts for Detecting Collision Eric Craft / Mead & Hunt - Collision Detection OmniGraph ____________________________________________ Notes: For the full sample scene to work, please download all of the .usd files in that folder as the main scene, Warehouse_Detect_Coll_OG, uses payloads of the graphs. If the graphs are not working, please ensure they are connected to the payload. You must have Physx Graph enabled from the Extension Manager in order for the Counter graph to work. If you add more packages to the scene, a Rigidbody with Colliders preset must be added, if not already on the package, then remove the Colliders from the Decal Mesh and the Scotch Mesh. Questions? Join me on Discord at discord.gg/nvidiaomniverse or email me at [email protected]	1,435	Markdown	38.888888	242	0.77561
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)	3,729	Python	35.213592	130	0.616251
dantreble/a2f/README.md	# a2f Unreal plugin to import json blendshape animations generated by audio2face in Nvidia Omniverse It can convert a blend shape channel to a bone transform:  It supports reimport and batch import.	261	Markdown	25.199997	94	0.804598
dantreble/a2f/Source/a2fEditor/Private/a2fOptionWindow.cpp	// Copyright Epic Games, Inc. All Rights Reserved. #include "a2fOptionWindow.h" #include "Modules/ModuleManager.h" #include "Widgets/Layout/SBorder.h" #include "Widgets/Text/STextBlock.h" #include "Widgets/Layout/SBox.h" #include "Widgets/Layout/SUniformGridPanel.h" #include "Widgets/Input/SButton.h" #include "EditorStyleSet.h" #include "Factories/FbxAnimSequenceImportData.h" #include "IDocumentation.h" #include "PropertyEditorModule.h" #include "IDetailsView.h" #define LOCTEXT_NAMESPACE "Fa2fEditorModule" void Sa2fOptionWindow::Construct(const FArguments& InArgs) { ImportUI = InArgs._ImportUI; WidgetWindow = InArgs._WidgetWindow; check (ImportUI); TSharedPtr<SBox> ImportTypeDisplay; TSharedPtr<SHorizontalBox> FbxHeaderButtons; TSharedPtr<SBox> InspectorBox; this->ChildSlot [ SNew(SBox) .MaxDesiredHeight(InArgs._MaxWindowHeight) .MaxDesiredWidth(InArgs._MaxWindowWidth) [ SNew(SVerticalBox) + SVerticalBox::Slot() .AutoHeight() .Padding(2) [ SAssignNew(ImportTypeDisplay, SBox) ] +SVerticalBox::Slot() .AutoHeight() .Padding(2) [ SNew(SBorder) .Padding(FMargin(3)) .BorderImage(FEditorStyle::GetBrush("ToolPanel.GroupBorder")) [ SNew(SHorizontalBox) +SHorizontalBox::Slot() .AutoWidth() [ SNew(STextBlock) .Font(FEditorStyle::GetFontStyle("CurveEd.LabelFont")) .Text(LOCTEXT("Import_CurrentFileTitle", "Current Asset: ")) ] +SHorizontalBox::Slot() .Padding(5, 0, 0, 0) .AutoWidth() .VAlign(VAlign_Center) [ SNew(STextBlock) .Font(FEditorStyle::GetFontStyle("CurveEd.InfoFont")) .Text(InArgs._FullPath) .ToolTipText(InArgs._FullPath) ] ] ] + SVerticalBox::Slot() .AutoHeight() .Padding(2) [ SAssignNew(InspectorBox, SBox) .MaxDesiredHeight(650.0f) .WidthOverride(400.0f) ] + SVerticalBox::Slot() .AutoHeight() .HAlign(HAlign_Right) .Padding(2) [ SNew(SUniformGridPanel) .SlotPadding(2) + SUniformGridPanel::Slot(0, 0) [ IDocumentation::Get()->CreateAnchor(FString("Engine/Content/FBX/ImportOptions")) ] + SUniformGridPanel::Slot(1, 0) [ SNew(SButton) .HAlign(HAlign_Center) .Text(LOCTEXT("FbxOptionWindow_ImportAll", "Import All")) .ToolTipText(LOCTEXT("FbxOptionWindow_ImportAll_ToolTip", "Import all files with these same settings")) .IsEnabled(this, &Sa2fOptionWindow::CanImport) .OnClicked(this, &Sa2fOptionWindow::OnImportAll) ] + SUniformGridPanel::Slot(2, 0) [ SAssignNew(ImportButton, SButton) .HAlign(HAlign_Center) .Text(LOCTEXT("FbxOptionWindow_Import", "Import")) .IsEnabled(this, &Sa2fOptionWindow::CanImport) .OnClicked(this, &Sa2fOptionWindow::OnImport) ] + SUniformGridPanel::Slot(3, 0) [ SNew(SButton) .HAlign(HAlign_Center) .Text(LOCTEXT("FbxOptionWindow_Cancel", "Cancel")) .ToolTipText(LOCTEXT("FbxOptionWindow_Cancel_ToolTip", "Cancels importing this FBX file")) .OnClicked(this, &Sa2fOptionWindow::OnCancel) ] ] ] ]; FPropertyEditorModule& PropertyEditorModule = FModuleManager::GetModuleChecked<FPropertyEditorModule>("PropertyEditor"); FDetailsViewArgs DetailsViewArgs; DetailsViewArgs.bAllowSearch = false; DetailsViewArgs.NameAreaSettings = FDetailsViewArgs::HideNameArea; DetailsView = PropertyEditorModule.CreateDetailView(DetailsViewArgs); InspectorBox->SetContent(DetailsView->AsShared()); ImportTypeDisplay->SetContent( SNew(SBorder) .Padding(FMargin(3)) .BorderImage(FEditorStyle::GetBrush("ToolPanel.GroupBorder")) [ SNew(SHorizontalBox) + SHorizontalBox::Slot() .VAlign(VAlign_Center) [ SNew(STextBlock) .Text(this, &Sa2fOptionWindow::GetImportTypeDisplayText) ] + SHorizontalBox::Slot() [ SNew(SBox) .HAlign(HAlign_Right) [ SAssignNew(FbxHeaderButtons, SHorizontalBox) + SHorizontalBox::Slot() .AutoWidth() .Padding(FMargin(2.0f, 0.0f)) [ SNew(SButton) .Text(LOCTEXT("FbxOptionWindow_ResetOptions", "Reset to Default")) .OnClicked(this, &Sa2fOptionWindow::OnResetToDefaultClick) ] ] ] ] ); DetailsView->SetObject(ImportUI); } FReply Sa2fOptionWindow::OnImport() { bShouldImport = true; if ( WidgetWindow.IsValid() ) { WidgetWindow.Pin()->RequestDestroyWindow(); } return FReply::Handled(); } FReply Sa2fOptionWindow::OnCancel() { bShouldImport = false; bShouldImportAll = false; if ( WidgetWindow.IsValid() ) { WidgetWindow.Pin()->RequestDestroyWindow(); } return FReply::Handled(); } FReply Sa2fOptionWindow::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) { if( InKeyEvent.GetKey() == EKeys::Escape ) { return OnCancel(); } return FReply::Unhandled(); } bool Sa2fOptionWindow::ShouldImport() const { return bShouldImport; } FReply Sa2fOptionWindow::OnResetToDefaultClick() const { ImportUI->ResetToDefault(); //Refresh the view to make sure the custom UI are updating correctly DetailsView->SetObject(ImportUI, true); return FReply::Handled(); } FText Sa2fOptionWindow::GetImportTypeDisplayText() const { return ImportUI->bIsReimport ? LOCTEXT("FbxOptionWindow_ReImportTypeAnim", "Reimport Animation") : LOCTEXT("FbxOptionWindow_ImportTypeAnim", "Import Animation"); } bool Sa2fOptionWindow::CanImport() const { // do test to see if we are ready to import if (ImportUI->Skeleton == NULL) { return false; } //if (ImportUI->AnimSequenceImportData->AnimationLength == FBXALIT_SetRange) //{ // if (ImportUI->AnimSequenceImportData->FrameImportRange.Min > ImportUI->AnimSequenceImportData->FrameImportRange.Max) // { // return false; // } //} return true; } #undef LOCTEXT_NAMESPACE	5,784	C++	24.372807	162	0.703147
dantreble/a2f/Source/a2fEditor/Private/a2fEditor.cpp	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #include "a2fEditor.h" #define LOCTEXT_NAMESPACE "Fa2fEditorModule" void Fa2fEditorModule::StartupModule() { // This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module } void Fa2fEditorModule::ShutdownModule() { // This function may be called during shutdown to clean up your module. For modules that support dynamic reloading, // we call this function before unloading the module. } #undef LOCTEXT_NAMESPACE IMPLEMENT_MODULE(Fa2fEditorModule, a2f)	593	C++	28.699999	129	0.784148
dantreble/a2f/Source/a2fEditor/Private/a2fImportUI.cpp	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #include "a2fImportUI.h" #include "a2fAssetImportData.h" #include "AnimationUtils.h" Ua2fImportUI::Ua2fImportUI() { ResetToDefault(); } void Ua2fImportUI::ResetToDefault() { AnimSequenceImportData = CreateDefaultSubobject<Ua2fAssetImportData>(TEXT("AnimSequenceImportData"), true); BoneCompressionSettings = FAnimationUtils::GetDefaultAnimationBoneCompressionSettings(); CurveCompressionSettings = FAnimationUtils::GetDefaultAnimationCurveCompressionSettings(); }	541	C++	21.583332	108	0.815157
dantreble/a2f/Source/a2fEditor/Private/a2fAssetImportData.cpp	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #include "a2fAssetImportData.h" void Ua2fAssetImportData::GetCurvesToStrip(TSet<FString> &CurvesToStrip) const { for (const FCurveDrivenBoneTransform &CurveDrivenBoneTransform : CurveDrivenBoneTransforms) { for (const FCurveDrivenTransform &CurveDrivenTransform : CurveDrivenBoneTransform.CurveDrivenTransforms) { if(CurveDrivenTransform.StripCurveTrack) { CurvesToStrip.Add(CurveDrivenTransform.Curve); } } } }	502	C++	24.149999	106	0.794821
dantreble/a2f/Source/a2fEditor/Private/a2fFactory.cpp	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #include "a2fFactory.h" #include "a2fAssetImportData.h" #include "a2fImportUI.h" #include "a2fOptionWindow.h" #include "AnimationUtils.h" #include "EditorFramework/AssetImportData.h" #include "Interfaces/IMainFrameModule.h" #include "Misc/FileHelper.h" #include "Serialization/JsonSerializer.h" #include "HAL/PlatformApplicationMisc.h" Ua2fFactory::Ua2fFactory(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { bCreateNew = false; bEditorImport = true; bText = true; bShowOption = true; bOperationCanceled = false; ImportUI = nullptr; SupportedClass = UAnimSequence::StaticClass(); Formats.Add("json;JavaScript Object Notation"); } void Ua2fFactory::PostInitProperties() { ImportUI = NewObject<Ua2fImportUI>(this, NAME_None, RF_NoFlags); Super::PostInitProperties(); } bool Ua2fFactory::FactoryCanImport(const FString& Filename) { return true; } inline UObject* Ua2fFactory::FactoryCreateText(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, const TCHAR* Type, const TCHAR*& Buffer, const TCHAR* BufferEnd, FFeedbackContext* Warn, bool& bOutOperationCanceled) { //We are not re-importing ImportUI->bIsReimport = false; //ImportUI->ReimportMesh = nullptr; //ImportUI->bAllowContentTypeImport = true; // Show the import dialog only when not in a "yes to all" state or when automating import bool bIsAutomated = IsAutomatedImport(); bool bShowImportDialog = bShowOption && !bIsAutomated; bool bImportAll = false; //Only try and read the old data on individual imports if(bShowImportDialog) { if (const UAnimSequence* ExistingAnimSequence = FindObject<UAnimSequence>(InParent, *InName.ToString())) { ImportUI->Skeleton = ExistingAnimSequence->GetSkeleton(); ImportUI->BoneCompressionSettings = ExistingAnimSequence->BoneCompressionSettings; ImportUI->CurveCompressionSettings = ExistingAnimSequence->CurveCompressionSettings; if (Ua2fAssetImportData* ExistingImportData = Cast<Ua2fAssetImportData>(ExistingAnimSequence->AssetImportData)) { ImportUI->AnimSequenceImportData = ExistingImportData; } } } if(bShowImportDialog) { TSharedPtr<SWindow> ParentWindow; if (FModuleManager::Get().IsModuleLoaded("MainFrame")) { IMainFrameModule& MainFrame = FModuleManager::LoadModuleChecked<IMainFrameModule>("MainFrame"); ParentWindow = MainFrame.GetParentWindow(); } // Compute centered window position based on max window size, which include when all categories are expanded const float ImportWindowWidth = 410.0f; const float ImportWindowHeight = 750.0f; FVector2D ImportWindowSize = FVector2D(ImportWindowWidth, ImportWindowHeight); // Max window size it can get based on current slate const FSlateRect WorkAreaRect = FSlateApplicationBase::Get().GetPreferredWorkArea(); const FVector2D DisplayTopLeft(WorkAreaRect.Left, WorkAreaRect.Top); const FVector2D DisplaySize(WorkAreaRect.Right - WorkAreaRect.Left, WorkAreaRect.Bottom - WorkAreaRect.Top); const float ScaleFactor = FPlatformApplicationMisc::GetDPIScaleFactorAtPoint(DisplayTopLeft.X, DisplayTopLeft.Y); ImportWindowSize *= ScaleFactor; const FVector2D WindowPosition = (DisplayTopLeft + (DisplaySize - ImportWindowSize) / 2.0f) / ScaleFactor; TSharedRef<SWindow> Window = SNew(SWindow) .Title(NSLOCTEXT("UnrealEd", "a2fImportOpionsTitle", "a2f Import Options")) .SizingRule(ESizingRule::Autosized) .AutoCenter(EAutoCenter::None) .ClientSize(ImportWindowSize) .ScreenPosition(WindowPosition); TSharedPtr<Sa2fOptionWindow> A2FOptionWindow; Window->SetContent ( SAssignNew(A2FOptionWindow, Sa2fOptionWindow) .ImportUI(ImportUI) .WidgetWindow(Window) .FullPath(FText::FromString(InParent->GetPathName())) .MaxWindowHeight(ImportWindowHeight) .MaxWindowWidth(ImportWindowWidth) ); FSlateApplication::Get().AddModalWindow(Window, ParentWindow, false); bImportAll = A2FOptionWindow->ShouldImportAll(); bOperationCanceled |= !A2FOptionWindow->ShouldImport(); } if(bOperationCanceled) { bOutOperationCanceled = true; return nullptr; } if(bImportAll) { // If the user chose to import all, we don't show the dialog again and use the same settings for each object until importing another set of files bShowOption = false; } UAnimSequence* AnimSequence = CastChecked<UAnimSequence>(CreateOrOverwriteAsset(InClass, InParent, InName, Flags)); if( AnimSequence == nullptr) { return nullptr; } USkeleton* Skeleton = ImportUI->Skeleton; AnimSequence->SetSkeleton(Skeleton); Ua2fAssetImportData* ImportData = Cast<Ua2fAssetImportData>(AnimSequence->AssetImportData); if (!ImportData) { ImportData = NewObject<Ua2fAssetImportData>(AnimSequence, NAME_None, RF_NoFlags, ImportUI->AnimSequenceImportData); // Try to preserve the source file data if possible if (AnimSequence->AssetImportData != nullptr) { ImportData->SourceData = AnimSequence->AssetImportData->SourceData; } AnimSequence->AssetImportData = ImportData; } AnimSequence->AssetImportData->AddFileName(UFactory::GetCurrentFilename(), 0); TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject()); const TSharedRef<TJsonReader<>> JsonReader = TJsonReaderFactory<>::Create(Buffer); if (!(JsonObject.IsValid() && FJsonSerializer::Deserialize(JsonReader, JsonObject))) { return nullptr; } int32 NumPoses; JsonObject->TryGetNumberField(TEXT("numPoses"), NumPoses); int32 NumFrames; JsonObject->TryGetNumberField(TEXT("numFrames"), NumFrames); TArray<FString> CurveNames; JsonObject->TryGetStringArrayField(TEXT("facsNames"), CurveNames); const TArray<TSharedPtr<FJsonValue>>* WeightMat; JsonObject->TryGetArrayField(TEXT("weightMat"), WeightMat); const int32 FPS = ImportUI->AnimSequenceImportData->FrameRate; if (CurveNames.Num() == 0 || WeightMat == nullptr) { return nullptr; } bool bIsAdditiveAnim = ImportUI->AnimSequenceImportData->AdditiveAnimType == AAT_LocalSpaceBase || ImportUI->AnimSequenceImportData->AdditiveAnimType == AAT_RotationOffsetMeshSpace; const int32 Frames = WeightMat->Num(); TSet<FString> CurvesToStrip; ImportUI->AnimSequenceImportData->GetCurvesToStrip(CurvesToStrip); for(int32 CurveIndex = 0; CurveIndex < CurveNames.Num(); ++CurveIndex) { const FString& CurveName = CurveNames[CurveIndex]; if(CurvesToStrip.Contains(CurveName)) { continue; } const USkeleton::AnimCurveUID CurveUID = Skeleton->GetUIDByName(USkeleton::AnimCurveMappingName, *CurveName); if (CurveUID == SmartName::MaxUID) { continue; } TArray<FRichCurveKey> Keys; Keys.Reserve(Frames); float WeightMin = FLT_MAX; float WeightMax = FLT_MIN; for (int32 FrameIndex = 0; FrameIndex < Frames; ++FrameIndex) { const TSharedPtr<FJsonValue>& WeightRow = (*WeightMat)[FrameIndex]; const float Time = static_cast<float>(FrameIndex) / FPS; const TArray<TSharedPtr<FJsonValue>>& WeightValues = WeightRow->AsArray(); const float Weight = WeightValues[CurveIndex]->AsNumber(); WeightMin = FMath::Min(WeightMin, Weight); WeightMax = FMath::Max(WeightMax, Weight); Keys.Add(FRichCurveKey(Time, Weight)); } //If the anim is additive and all the values are zero, don't bother adding a track if(bIsAdditiveAnim && FMath::IsNearlyEqual(WeightMin,0.0f) && FMath::IsNearlyEqual(WeightMax, 0.0f)) { continue; } FSmartName SmartName; Skeleton->GetSmartNameByUID(USkeleton::AnimCurveMappingName, CurveUID, SmartName); AnimSequence->RawCurveData.AddCurveData(SmartName); FFloatCurve* FloatCurveData = static_cast<FFloatCurve*>(AnimSequence->RawCurveData.GetCurveData(CurveUID)); FloatCurveData->FloatCurve.SetKeys(Keys); } for (FCurveDrivenBoneTransform &CurveDrivenBoneTransform : ImportUI->AnimSequenceImportData->CurveDrivenBoneTransforms) { FRawAnimSequenceTrack RawTrack; RawTrack.PosKeys.Empty(); RawTrack.RotKeys.Empty(); RawTrack.ScaleKeys.Empty(); TArray<int32> CurveIndices; for (const FCurveDrivenTransform &CurveDrivenTransform : CurveDrivenBoneTransform.CurveDrivenTransforms) { CurveIndices.Add(CurveNames.Find(CurveDrivenTransform.Curve)); } const FReferenceSkeleton &ReferenceSkeleton = Skeleton->GetReferenceSkeleton(); const TArray<FTransform> &RawRefBonePose = ReferenceSkeleton.GetRawRefBonePose(); int32 RawBoneIndex = ReferenceSkeleton.FindRawBoneIndex(CurveDrivenBoneTransform.Bone); FTransform RawBonePose = RawBoneIndex != INDEX_NONE ? RawRefBonePose[RawBoneIndex] : FTransform::Identity; for (int32 FrameIndex = 0; FrameIndex < Frames; ++FrameIndex) { FTransform LocalTransform; const TSharedPtr<FJsonValue>& WeightRow = (*WeightMat)[FrameIndex]; const TArray<TSharedPtr<FJsonValue>>& WeightValues = WeightRow->AsArray(); for (int32 CurveDrivenIndex = 0; CurveDrivenIndex < CurveDrivenBoneTransform.CurveDrivenTransforms.Num(); ++CurveDrivenIndex) { int32 CurveIndex = CurveIndices[CurveDrivenIndex]; if(CurveIndex == INDEX_NONE) { continue; } FCurveDrivenTransform &CurveDrivenTransform = CurveDrivenBoneTransform.CurveDrivenTransforms[CurveDrivenIndex]; FTransform::BlendFromIdentityAndAccumulate(LocalTransform, CurveDrivenTransform.Transform, ScalarRegister(WeightValues[CurveIndex]->AsNumber())); } FTransform CombinedTransform = RawBonePose* LocalTransform; RawTrack.ScaleKeys.Add(CombinedTransform.GetScale3D()); RawTrack.PosKeys.Add(CombinedTransform.GetTranslation()); RawTrack.RotKeys.Add(CombinedTransform.GetRotation()); } AnimSequence->AddNewRawTrack(CurveDrivenBoneTransform.Bone, &RawTrack); } AnimSequence->SetRawNumberOfFrame(Frames); AnimSequence->SequenceLength = static_cast<float>(FMath::Max(Frames - 1, 1)) / FPS; AnimSequence->ImportFileFramerate = FPS; AnimSequence->BoneCompressionSettings = ImportUI->BoneCompressionSettings; AnimSequence->CurveCompressionSettings = ImportUI->CurveCompressionSettings; AnimSequence->AdditiveAnimType = ImportUI->AnimSequenceImportData->AdditiveAnimType; return AnimSequence; } void Ua2fFactory::CleanUp() { bShowOption = true; bOperationCanceled = false; Super::CleanUp(); } int32 Ua2fFactory::GetPriority() const { return INT32_MAX; } bool Ua2fFactory::CanReimport(UObject* Obj, TArray<FString>& OutFilenames) { if(const UAnimSequence* AnimSequence = Cast<UAnimSequence>(Obj)) { if(const UAssetImportData* AssetImportData = AnimSequence->AssetImportData) { AssetImportData->ExtractFilenames(OutFilenames); return true; } } return false; } void Ua2fFactory::SetReimportPaths(UObject* Obj, const TArray<FString>& NewReimportPaths) { if (const UAnimSequence* AnimSequence = Cast<UAnimSequence>(Obj)) { if(NewReimportPaths.Num() == 1) { if(UAssetImportData* AssetImportData = AnimSequence->AssetImportData) { AssetImportData->UpdateFilenameOnly(NewReimportPaths[0]); } } } } EReimportResult::Type Ua2fFactory::Reimport(UObject* Obj) { const UAnimSequence* AnimSequence = Cast<UAnimSequence>(Obj); if (AnimSequence == nullptr) { return EReimportResult::Failed; } const FString ResolvedSourceFilePath = AnimSequence->AssetImportData->GetFirstFilename(); if (ResolvedSourceFilePath.IsEmpty()) { return EReimportResult::Failed; } if (IFileManager::Get().FileSize(*ResolvedSourceFilePath) == INDEX_NONE) { return EReimportResult::Failed; } bool bOutCanceled = false; if (ImportObject(AnimSequence->GetClass(), AnimSequence->GetOuter(), *AnimSequence->GetName(), RF_Public | RF_Standalone, ResolvedSourceFilePath, nullptr, bOutCanceled)) { return EReimportResult::Succeeded; } if (bOutCanceled) { return EReimportResult::Cancelled; } return EReimportResult::Failed; }	11,808	C++	28.972081	182	0.766599
dantreble/a2f/Source/a2fEditor/Public/a2fEditor.h	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "Modules/ModuleManager.h" class Fa2fEditorModule : public IModuleInterface { public: /** IModuleInterface implementation */ virtual void StartupModule() override; virtual void ShutdownModule() override; };	324	C	19.312499	63	0.777778
dantreble/a2f/Source/a2fEditor/Public/a2fAssetImportData.h	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "EditorFramework/AssetImportData.h" #include "a2fAssetImportData.generated.h" /** * */ USTRUCT(BlueprintType) struct FCurveDrivenTransform { GENERATED_BODY() UPROPERTY(EditAnywhere, BlueprintReadWrite) FString Curve; UPROPERTY(EditAnywhere, BlueprintReadWrite) bool StripCurveTrack = true; UPROPERTY(EditAnywhere, BlueprintReadWrite) FTransform Transform; }; USTRUCT(BlueprintType) struct FCurveDrivenBoneTransform { GENERATED_BODY() UPROPERTY(EditAnywhere, BlueprintReadWrite) FName Bone; UPROPERTY(EditAnywhere, BlueprintReadWrite) TArray<FCurveDrivenTransform> CurveDrivenTransforms; }; UCLASS(BlueprintType) class A2FEDITOR_API Ua2fAssetImportData : public UAssetImportData { GENERATED_BODY() public: UFUNCTION() void GetCurvesToStrip(TSet<FString>& CurvesToStrip) const; /** Use this option to specify a sample rate for the imported animation*/ UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ToolTip = "Animation frames per second", ClampMin = 0, UIMin = 0, ClampMax = 48000, UIMax = 60)) int32 FrameRate = 30; UPROPERTY(EditAnywhere, BlueprintReadWrite) TEnumAsByte<enum EAdditiveAnimationType> AdditiveAnimType = AAT_LocalSpaceBase; UPROPERTY(EditAnywhere,BlueprintReadWrite) TArray<FCurveDrivenBoneTransform> CurveDrivenBoneTransforms; };	1,405	C	22.04918	149	0.798577
dantreble/a2f/Source/a2fEditor/Public/a2fFactory.h	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "Factories/Factory.h" #include "EditorReimportHandler.h" #include "a2fFactory.generated.h" /** * */ UCLASS() class A2FEDITOR_API Ua2fFactory : public UFactory, public FReimportHandler { GENERATED_UCLASS_BODY() public: Ua2fFactory(); virtual void PostInitProperties() override; virtual bool FactoryCanImport(const FString& Filename) override; virtual UObject* FactoryCreateText(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, const TCHAR* Type, const TCHAR*& Buffer, const TCHAR* BufferEnd, FFeedbackContext* Warn, bool& bOutOperationCanceled) override; virtual void CleanUp() override; // FReimportHandler virtual int32 GetPriority() const override; virtual bool CanReimport(UObject* Obj, TArray<FString>& OutFilenames) override; virtual void SetReimportPaths(UObject* Obj, const TArray<FString>& NewReimportPaths) override; virtual EReimportResult::Type Reimport(UObject* Obj) override; private: UPROPERTY() class Ua2fImportUI* ImportUI; bool bShowOption; /** true if the import operation was canceled. */ bool bOperationCanceled; };	1,227	C	22.615384	108	0.772616
dantreble/a2f/Source/a2fEditor/Public/a2fImportUI.h	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "a2fImportUI.generated.h" /** * */ UCLASS(BlueprintType, HideCategories = Object, MinimalAPI) class Ua2fImportUI : public UObject { public: Ua2fImportUI(); private: GENERATED_BODY() public: void ResetToDefault(); /** Skeleton to use for imported asset. When importing a mesh, leaving this as "None" will create a new skeleton. When importing an animation this MUST be specified to import the asset. */ UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ImportSettings, meta = (ImportType = "SkeletalMesh|Animation")) class USkeleton* Skeleton; /** The bone compression settings used to compress bones in this sequence. */ UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ImportSettings) class UAnimBoneCompressionSettings* BoneCompressionSettings; /** The curve compression settings used to compress curves in this sequence. */ UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = ImportSettings) class UAnimCurveCompressionSettings* CurveCompressionSettings; UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, Instanced, Category = ImportSettings) class Ua2fAssetImportData* AnimSequenceImportData; bool bIsReimport; };	1,278	C	29.45238	189	0.788732
dantreble/a2f/Source/a2fEditor/Public/a2fOptionWindow.h	// Copyright Spitfire Interactive Pty Ltd. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "InputCoreTypes.h" #include "Widgets/DeclarativeSyntaxSupport.h" #include "Input/Reply.h" #include "Widgets/SCompoundWidget.h" #include "Widgets/SWindow.h" #include "a2fImportUI.h" class SButton; class A2FEDITOR_API Sa2fOptionWindow : public SCompoundWidget { public: SLATE_BEGIN_ARGS( Sa2fOptionWindow ) : _ImportUI(NULL) , _WidgetWindow() , _FullPath() , _MaxWindowHeight(0.0f) , _MaxWindowWidth(0.0f) {} SLATE_ARGUMENT( Ua2fImportUI*, ImportUI ) SLATE_ARGUMENT( TSharedPtr<SWindow>, WidgetWindow ) SLATE_ARGUMENT( FText, FullPath ) SLATE_ARGUMENT( float, MaxWindowHeight) SLATE_ARGUMENT(float, MaxWindowWidth) SLATE_END_ARGS() public: void Construct(const FArguments& InArgs); virtual bool SupportsKeyboardFocus() const override { return true; } FReply OnImport(); FReply OnImportAll() { bShouldImportAll = true; return OnImport(); } FReply OnCancel(); virtual FReply OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent ) override; bool ShouldImport() const; bool ShouldImportAll() const { return bShouldImportAll; } Sa2fOptionWindow() : ImportUI(NULL) , bShouldImport(false) , bShouldImportAll(false) {} private: bool CanImport() const; FReply OnResetToDefaultClick() const; FText GetImportTypeDisplayText() const; Ua2fImportUI* ImportUI; TSharedPtr<class IDetailsView> DetailsView; TWeakPtr< SWindow > WidgetWindow; TSharedPtr< SButton > ImportButton; bool bShouldImport; bool bShouldImportAll; };	1,612	C	20.506666	95	0.747519
Vadim-Karpenko/omniverse-material-manager-extended/CHANGELOG.md	# Change Log All notable changes to this project will be documented in this file. ## [1.1.1] - 2022-12-26 ### Fixed Support of Create 2022.3.1 ## [1.1.1] - 2022-10-04 ### Fixed Convert icon and preview_image to png format ## [1.1.0] - 2022-09-26 ### Added #### Roaming mode (settings tab) Allowing you to automatically select an object just by looking at it. Note that this can cause difficulty when creating new objects with variants, so it's best to only enable this mode when your scene is ready for demonstration. ### Fixed - Fixed possible crash caused by iterating through history of commands. ## [1.0.1] - 2022-08-26 ### Added - Support of a new version of viewport (Next viewport). ## [1.0.0] - 2022-08-18 Initial release.	757	Markdown	18.947368	158	0.694848
Vadim-Karpenko/omniverse-material-manager-extended/README.md	# Material Manager Extended  ### About This extension will let you quickly toggle between different materials for the static objects in your scene. ## Quick links * [Installation](#installation) * [Restrictions](#restrictions) * [How to use](#how-to-use) * [Linking with an Omniverse app](#linking-with-an-omniverse-app) * [Contributing](#contributing) * [Changelog](CHANGELOG.md) ## Installation To add a this extension to your Omniverse app: ### From Community tab 1. Go to **Extension Manager** (Window - Extensions) — Community tab 2. Search for **Material Manager** extension and enable it ### Manual 1. Go to **Extension Manager** (Window - Extensions) — **Gear Icon** — **Extension Search Path** 2. Add this as a search path: `git://github.com/Vadim-Karpenko/omniverse-material-manager-extended?branch=main&dir=exts` 3. Search for **Material Manager** extension and enable it A new window will appear alongside the Property tab:  ## Restrictions - Some vegetation can cause problems, but most should work just fine. - Currently has no support of instanced meshes (they usually greyed out and aren't accessible). - Your object needs to have the following structure:  Most objects already have this structure, especially from **Nvidia Assets** tab, but in some custom cases, you might need to change your object so it corresponds to the structure from above. Note: Looks folder can be empty, and your original textures located somewhere else, it just tells the extension that this is a separate object. #### Example:  - It will not work with the primitives, because it does not corresponds to the structure from above. ## How to use - Navigate to your viewport and select any static object on your scene - Once an object is selected and is valid (see restrictions), the window will be changed into something similar to this:  - Click **Add new variant** at the bottom of the window. A new variant called _Look_1_ will appear in the list. You can create as many as you need, and if you need to rename your variant you can do it by renaming appropriate folder in **Looks/MME/your_variant**  - You will see a viewport window on top of your model. Change material or replace it completely while your variant is active   - Now you can toggle between those variants   - More complex Xform's are also supported. This means that the extension will toggle all the materials for every mesh at once under this Xform.  ## Linking with an Omniverse app For a better developer experience, it is recommended to create a folder link named `app` to the *Omniverse Kit* app installed from *Omniverse Launcher*. A convenience script to use is included. Run: ```bash > link_app.bat ``` There is also an analogous `link_app.sh` for Linux. If successful you should see `app` folder link in the root of this repo. If multiple Omniverse apps is installed script will select recommended one. Or you can explicitly pass an app: ```bash > link_app.bat --app code ``` You can also just pass a path to create link to: ```bash > link_app.bat --path "C:/Users/bob/AppData/Local/ov/pkg/create-2022.1.3" ``` ## Contributing Feel free to create a new issue if you run into any problems. Pull requests are welcomed.	3,671	Markdown	35.72	338	0.749387
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!")	2,813	Python	32.5	133	0.562389
Vadim-Karpenko/omniverse-material-manager-extended/tools/packman/config.packman.xml	<config remotes="cloudfront"> <remote2 name="cloudfront"> <transport actions="download" protocol="https" packageLocation="d4i3qtqj3r0z5.cloudfront.net/${name}@${version}" /> </remote2> </config>	211	XML	34.333328	123	0.691943
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])	1,888	Python	31.568965	103	0.68697
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	3,123	Python	32.956521	101	0.675312
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, } }	2,175	Python	27.25974	89	0.605057
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)	61,602	Python	44.329654	168	0.542271
Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/__init__.py	from .extension import *	25	Python	11.999994	24	0.76
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()}"	8,631	Python	39.336448	117	0.588228
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	2,570	Python	38.553846	97	0.624125
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	6,966	Python	34.728205	127	0.604795
Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/config/extension.toml	[package] # Semantic Versionning is used: https://semver.org/ version = "1.1.4" # The title and description fields are primarily for displaying extension info in UI title = "Material Manager" description="Allows you to quickly toggle between different materials" # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" # URL of the extension source repository. repository = "https://github.com/Vadim-Karpenko/omniverse-material-manager-extended" # One of categories for UI. category = "Material" # Keywords for the extension keywords = ["material", "materials", "manager", ] authors = ["Vadim Karpenko"] preview_image = "data/preview_image.png" icon = "data/icons/icon.png" # Use omni.ui to build simple UI [dependencies] "omni.kit.stage.copypaste" = {} "omni.kit.uiapp" = {} "omni.kit.viewport.utility" = { } "omni.ui.scene" = { } "omni.ui" = { } "omni.usd" = { } "omni.kit.usd_undo" = {} # Main python module this extension provides, it will be publicly available as "import karpenko.materialsmanager.ext". [[python.module]] name = "karpenko.materialsmanager.ext" dependencies = [ "omni.kit.renderer.core", "omni.kit.renderer.capture", ]	1,207	TOML	25.260869	118	0.716653
Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/docs/README.md	## Material Manager Extended This extension will let you quickly toggle between different materials for the static objects in your scene.	137	Markdown	67.999966	108	0.832117
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	1,428	Python	32.232557	87	0.60084
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	1,310	Python	28.795454	107	0.603817
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()	6,202	Python	42.377622	158	0.697356
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	2,796	Python	34.858974	115	0.545422
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)	721	Python	24.785713	64	0.736477
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	218	Python	53.749987	98	0.724771
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, )	4,208	Python	33.219512	111	0.642586
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)	1,769	Python	32.396226	127	0.62182
zslrmhb/Omniverse-Virtual-Assisstant/README.md	# Omniverse-Virtual-Assisstant using Riva Server (with Riva SDK, deployed in Google Cloud) and Audio2Face ## Demo [](https://youtu.be/kv9QM-SODIM "Video Title") ## Prerequisites - Riva Server - Audio2Face - In a conda environment(Prefer) - Riva Python Client: https://github.com/nvidia-riva/python-clients - Wikipedia APIs - https://pypi.org/project/wikipedia/ - https://pypi.org/project/Wikipedia-API/ <!-- ## Tutorial --> <!DOCTYPE html> <html> <head> </head> <body> <h1>Tutorial</h1> <p>The tutorial is here: <a href="Tutorials.pdf">Tutorial</a>.</p> </body> </html> ## How to Use? 1. Set up the Riva Server and Audio2Face as indicated by the steps in the Tutorial. 2. After step 1 has been set up, launch both the Riva Server and Audio2Face. 3. Fill in the URI in the config.py in the following format: external IP of your Riva Server:Port of your Riva Server. 1. For example, if the external IP of the Riva Sever is "12.34.56.789" and the port of the Riva Server is "50050". Then the content in config.py will be > URI = "12.34.56.789:50050" 3. Check if all the prerequisties are configured. 4. Run main.py. ## Inspired by https://github.com/metaiintw/build-an-avatar-with-ASR-TTS-Transformer-Omniverse-Audio2Face ## Limitations: Currently Using the Wikipedia API for NLP Context Query, so it can only handle Q&A questions that can be answer by Wikipedia.	1,474	Markdown	34.119047	157	0.717096
zslrmhb/Omniverse-Virtual-Assisstant/LICENSE.md	MIT License Copyright (c) 2023 Hongbin Miao Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.	1,069	Markdown	47.636361	78	0.805426
PegasusSimulator/PegasusSimulator/README.md	# Pegasus Simulator    **Pegasus Simulator** is a framework built on top of [NVIDIA Omniverse](https://docs.omniverse.nvidia.com/) and [Isaac Sim](https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/overview.html). It is designed to provide an easy yet powerful way of simulating the dynamics of vehicles. It provides a simulation interface for [PX4](https://px4.io/) integration as well as a custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions. <p align = "center"> <a href="https://youtu.be/_11OCFwf_GE" target="_blank"><img src="docs/_static/pegasus_cover.png" alt="Pegasus Simulator image" height="300"/></a> <a href="https://youtu.be/_11OCFwf_GE" target="_blank"><img src="docs/_static/mini demo.gif" alt="Pegasus Simulator gif" height="300"/></a> </p> Check the provided documentation [here](https://pegasussimulator.github.io/PegasusSimulator/) to discover how to install and use this framework. ## Citation If you find Pegasus Simulator useful in your academic work, please cite the paper below. It is also available [here](https://arxiv.org/abs/2307.05263). ``` @misc{jacinto2023pegasus, title={Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation}, author={Marcelo Jacinto and João Pinto and Jay Patrikar and John Keller and Rita Cunha and Sebastian Scherer and António Pascoal}, year={2023}, eprint={2307.05263}, archivePrefix={arXiv}, primaryClass={cs.RO} } ``` ## Main Developer Team This simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027. * Project Founder * [Marcelo Jacinto](https://github.com/MarceloJacinto), under the supervision of <u>Prof. Rita Cunha</u> and <u>Prof. Antonio Pascoal</u> (IST/ISR-Lisbon) * Architecture * [Marcelo Jacinto](https://github.com/MarceloJacinto) * [João Pinto](https://github.com/jschpinto) * Multirotor Dynamic Simulation and Control * [Marcelo Jacinto](https://github.com/MarceloJacinto) * Example Applications * [Marcelo Jacinto](https://github.com/MarceloJacinto) * [João Pinto](https://github.com/jschpinto) Also check the always up-to-date [Github contributors list](https://github.com/PegasusSimulator/PegasusSimulator/graphs/contributors) with all the open-source contributors. ## Project Roadmap An high level project roadmap is available [here](https://pegasussimulator.github.io/PegasusSimulator/source/references/roadmap.html). ## Support and Contributing We welcome new contributions from the community to improve this work. Please check the [Contributing](https://pegasussimulator.github.io/PegasusSimulator/source/references/contributing.html) section in the documentation for the guidelines on how to help improve and support this project. * Use [Discussions](https://github.com/PegasusSimulator/PegasusSimulator/discussions) for discussing ideas, asking questions, and requests features. * Use [Issues](https://github.com/PegasusSimulator/PegasusSimulator/issues) to track work in development, bugs and documentation issues. * Use [Pull Requests](https://github.com/PegasusSimulator/PegasusSimulator/pulls) to fix bugs or contribute directly with your own ideas, code, examples or improve documentation. ## Licenses Pegasus Simulator is released under [BSD-3 License](LICENSE). The license files of its dependencies and assets are present in the [`docs/licenses`](docs/licenses) directory. NVIDIA Isaac Sim is available freely under [individual license](https://www.nvidia.com/en-us/omniverse/download/). PX4-Autopilot is available as an open-source project under [BSD-3 License](https://github.com/PX4/PX4-Autopilot). ## Project Sponsors - Dynamics Systems and Ocean Robotics (DSOR) group of the Institute for Systems and Robotics (ISR), a research unit of the Laboratory of Robotics and Engineering Systems (LARSyS). - Instituto Superior Técnico, Universidade de Lisboa The work developed by Marcelo Jacinto and João Pinto was supported by Ph.D. grants funded by Fundação para a Ciência e Tecnologia (FCT). <p float="left" align="center"> <img src="docs/_static/dsor_logo.png" width="90" align="center" /> <img src="docs/_static/logo_isr.png" width="200" align="center"/> <img src="docs/_static/larsys_logo.png" width="200" align="center"/> <img src="docs/_static/ist_logo.png" width="200" align="center"/> <img src="docs/_static/logo_fct.png" width="200" align="center"/> </p>	4,976	Markdown	58.963855	417	0.76246
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()	4,153	Python	35.438596	192	0.667229
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()	6,750	Python	37.79885	128	0.652741
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()	6,518	Python	37.803571	128	0.642989
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()	4,001	Python	34.105263	121	0.652587
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()	4,878	Python	38.032	126	0.677532
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	18,171	Python	41.064815	149	0.587144
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, )	1,389	Python	31.325581	89	0.712743
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()	6,081	Python	37.493671	193	0.666996
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	285	Python	30.777774	82	0.740351
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"	3,070	Python	38.883116	111	0.739414
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)	635	Python	25.499999	56	0.699213
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	218	Python	15.846153	47	0.62844
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)	692	Python	27.874999	77	0.715318
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	3,406	Python	37.715909	106	0.57751
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	343	Python	30.272725	45	0.819242
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)	700	Python	28.208332	101	0.694286
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)	892	Python	29.793102	94	0.709641
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)	637	Python	24.519999	55	0.66719
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/ui/ui_window.py	""" | File: ui_window.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of WidgetWindow which contains all the UI code that defines the extension GUI """ __all__ = ["WidgetWindow"] # External packages import numpy as np # Omniverse general API import carb import omni.ui as ui from omni.ui import color as cl from pegasus.simulator.ui.ui_delegate import UIDelegate from pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS, THUMBNAIL, WORLD_THUMBNAIL, WINDOW_TITLE class WidgetWindow(ui.Window): # Design constants for the widgets LABEL_PADDING = 120 BUTTON_HEIGHT = 50 GENERAL_SPACING = 5 WINDOW_WIDTH = 325 WINDOW_HEIGHT = 850 BUTTON_SELECTED_STYLE = { "Button": { "background_color": 0xFF5555AA, "border_color": 0xFF5555AA, "border_width": 2, "border_radius": 5, "padding": 5, } } BUTTON_BASE_STYLE = { "Button": { "background_color": cl("#292929"), "border_color": cl("#292929"), "border_width": 2, "border_radius": 5, "padding": 5, } } def __init__(self, delegate: UIDelegate, **kwargs): """ Constructor for the Window UI widget of the extension. Receives as input a UIDelegate that implements all the callbacks to handle button clicks, drop-down menu actions, etc. (abstracting the interface between the logic of the code and the ui) """ # Setup the base widget window super().__init__( WINDOW_TITLE, width=WidgetWindow.WINDOW_WIDTH, height=WidgetWindow.WINDOW_HEIGHT, visible=True, **kwargs ) self.deferred_dock_in("Property", ui.DockPolicy.CURRENT_WINDOW_IS_ACTIVE) # Setup the delegate that will bridge between the logic and the UI self._delegate = delegate # Bind the UI delegate to this window self._delegate.set_window_bind(self) # Auxiliar attributes for getting the transforms of the vehicle and the camera from the UI self._camera_transform_models = [] self._vehicle_transform_models = [] # Build the actual window UI self._build_window() def destroy(self): # Clear the world and the stage correctly self._delegate.on_clear_scene() # It will destroy all the children super().destroy() def _build_window(self): # Define the UI of the widget window with self.frame: with ui.ScrollingFrame(horizontal_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_ON, vertical_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_ON): # Vertical Stack of menus with ui.VStack(): # Create a frame for selecting which scene to load self._scene_selection_frame() ui.Spacer(height=5) # Create a frame for selecting which vehicle to load in the simulation environment self._robot_selection_frame() ui.Spacer(height=5) # Create a frame for selecting the camera position, and what it should point torwards to self._viewport_camera_frame() ui.Spacer() def _scene_selection_frame(self): """ Method that implements a dropdown menu with the list of available simulation environemts for the vehicle """ # Frame for selecting the simulation environment to load with ui.CollapsableFrame("Scene Selection"): with ui.VStack(height=0, spacing=10, name="frame_v_stack"): ui.Spacer(height=WidgetWindow.GENERAL_SPACING) # Iterate over all existing pre-made worlds bundled with this extension with ui.HStack(): ui.Label("World Assets", width=WidgetWindow.LABEL_PADDING, height=10.0) # Combo box with the available environments to select from dropdown_menu = ui.ComboBox(0, height=10, name="environments") for environment in SIMULATION_ENVIRONMENTS: dropdown_menu.model.append_child_item(None, ui.SimpleStringModel(environment)) # Allow the delegate to know which option was selected in the dropdown menu self._delegate.set_scene_dropdown(dropdown_menu.model) ui.Spacer(height=0) # UI to configure the default latitude, longitude and altitude coordinates with ui.CollapsableFrame("Geographic Coordinates", collapsed=False): with ui.VStack(height=0, spacing=10, name="frame_v_stack"): with ui.HStack(): # Latitude ui.Label("Latitude", name="label", width=WidgetWindow.LABEL_PADDING-50) latitude_field = ui.FloatField(name="latitude", precision=6) latitude_field.model.set_value(self._delegate._latitude) self._delegate.set_latitude_field(latitude_field.model) ui.Circle(name="transform", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED) # Longitude ui.Label("Longitude", name="label", width=WidgetWindow.LABEL_PADDING-50) longitude_field = ui.FloatField(name="longitude", precision=6) longitude_field.model.set_value(self._delegate._longitude) self._delegate.set_longitude_field(longitude_field.model) ui.Circle(name="transform", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED) # Altitude ui.Label("Altitude", name="label", width=WidgetWindow.LABEL_PADDING-50) altitude_field = ui.FloatField(name="altitude", precision=6) altitude_field.model.set_value(self._delegate._altitude) self._delegate.set_altitude_field(altitude_field.model) ui.Circle(name="transform", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED) with ui.HStack(): ui.Button("Set", enabled=True, clicked_fn=self._delegate.on_set_new_global_coordinates) ui.Button("Reset", enabled=True, clicked_fn=self._delegate.on_reset_global_coordinates) ui.Button("Make Default", enabled=True, clicked_fn=self._delegate.on_set_new_default_global_coordinates) ui.Spacer(height=0) with ui.HStack(): # Add a thumbnail image to have a preview of the world that is about to be loaded with ui.ZStack(width=WidgetWindow.LABEL_PADDING, height=WidgetWindow.BUTTON_HEIGHT * 2): ui.Rectangle() ui.Image( WORLD_THUMBNAIL, fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT, alignment=ui.Alignment.LEFT_CENTER, ) ui.Spacer(width=WidgetWindow.GENERAL_SPACING) with ui.VStack(): # Button for loading a desired scene ui.Button( "Load Scene", height=WidgetWindow.BUTTON_HEIGHT, clicked_fn=self._delegate.on_load_scene, style=WidgetWindow.BUTTON_BASE_STYLE, ) # Button to reset the stage ui.Button( "Clear Scene", height=WidgetWindow.BUTTON_HEIGHT, clicked_fn=self._delegate.on_clear_scene, style=WidgetWindow.BUTTON_BASE_STYLE, ) def _robot_selection_frame(self): """ Method that implements a frame that allows the user to choose which robot that is about to be spawned """ # Auxiliary function to handle the "switch behaviour" of the buttons that are used to choose between a px4 or ROS2 backend def handle_px4_ros_switch(self, px4_button, ros2_button, button): # Handle the UI of both buttons switching of and on (To make it prettier) if button == "px4": px4_button.enabled = False ros2_button.enabled = True px4_button.set_style(WidgetWindow.BUTTON_SELECTED_STYLE) ros2_button.set_style(WidgetWindow.BUTTON_BASE_STYLE) else: px4_button.enabled = True ros2_button.enabled = False ros2_button.set_style(WidgetWindow.BUTTON_SELECTED_STYLE) px4_button.set_style(WidgetWindow.BUTTON_BASE_STYLE) # Handle the logic of switching between the two operating modes self._delegate.set_streaming_backend(button) # -------------------------- # Function UI starts here # -------------------------- # Frame for selecting the vehicle to load with ui.CollapsableFrame(title="Vehicle Selection"): with ui.VStack(height=0, spacing=10, name="frame_v_stack"): ui.Spacer(height=WidgetWindow.GENERAL_SPACING) # Iterate over all existing robots in the extension with ui.HStack(): ui.Label("Vehicle Model", name="label", width=WidgetWindow.LABEL_PADDING) # Combo box with the available vehicles to select from dropdown_menu = ui.ComboBox(0, height=10, name="robots") for robot in ROBOTS: dropdown_menu.model.append_child_item(None, ui.SimpleStringModel(robot)) self._delegate.set_vehicle_dropdown(dropdown_menu.model) with ui.HStack(): ui.Label("Vehicle ID", name="label", width=WidgetWindow.LABEL_PADDING) vehicle_id_field = ui.IntField() self._delegate.set_vehicle_id_field(vehicle_id_field.model) # Add a frame transform to select the position of where to place the selected robot in the world self._transform_frame() ui.Label("Streaming Backend") with ui.HStack(): # Add a thumbnail image to have a preview of the world that is about to be loaded with ui.ZStack(width=WidgetWindow.LABEL_PADDING, height=WidgetWindow.BUTTON_HEIGHT * 2): ui.Rectangle() ui.Image( THUMBNAIL, fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT, alignment=ui.Alignment.LEFT_CENTER ) ui.Spacer(width=WidgetWindow.GENERAL_SPACING) with ui.VStack(): # Buttons that behave like switches to choose which network interface to use to simulate the control of the vehicle px4_button = ui.Button( "PX4", height=WidgetWindow.BUTTON_HEIGHT * 2, style=WidgetWindow.BUTTON_SELECTED_STYLE, enabled=False, ) ros2_button = ui.Button( "ROS 2", height=WidgetWindow.BUTTON_HEIGHT, style=WidgetWindow.BUTTON_BASE_STYLE, enabled=True, visible=False ) # Set the auxiliary function to handle the switch between both backends px4_button.set_clicked_fn(lambda: handle_px4_ros_switch(self, px4_button, ros2_button, "px4")) ros2_button.set_clicked_fn(lambda: handle_px4_ros_switch(self, px4_button, ros2_button, "ros")) # UI to configure the PX4 settings with ui.CollapsableFrame("PX4 Configurations", collapsed=False): with ui.VStack(height=0, spacing=10, name="frame_v_stack"): with ui.HStack(): ui.Label("Auto-launch PX4", name="label", width=WidgetWindow.LABEL_PADDING - 20) px4_checkbox = ui.CheckBox() px4_checkbox.model.set_value(self._delegate._autostart_px4) self._delegate.set_px4_autostart_checkbox(px4_checkbox.model) with ui.HStack(): ui.Label("PX4 Path", name="label", width=WidgetWindow.LABEL_PADDING - 20) px4_path_field = ui.StringField(name="px4_path", width=300) px4_path_field.model.set_value(self._delegate._px4_dir) self._delegate.set_px4_directory_field(px4_path_field.model) ui.Button("Reset", enabled=True, clicked_fn=self._delegate.on_reset_px4_path) ui.Button("Make Default", enabled=True, clicked_fn=self._delegate.on_set_new_default_px4_path) with ui.HStack(): ui.Label("PX4 airframe", name="label", width=WidgetWindow.LABEL_PADDING - 20) px4_airframe_field = ui.StringField(name="px4_model") px4_airframe_field.model.set_value(self._delegate._px4_airframe) self._delegate.set_px4_airframe_field(px4_airframe_field.model) # Button to load the drone ui.Button( "Load Vehicle", height=WidgetWindow.BUTTON_HEIGHT, clicked_fn=self._delegate.on_load_vehicle, style=WidgetWindow.BUTTON_BASE_STYLE, ) def _viewport_camera_frame(self): """ Method that implements a frame that allows the user to choose what is the viewport camera pose easily """ all_axis = ["X", "Y", "Z"] colors = {"X": 0xFF5555AA, "Y": 0xFF76A371, "Z": 0xFFA07D4F} default_values = [5.0, 5.0, 5.0] target_default_values = [0.0, 0.0, 0.0] # Frame for setting the camera to visualize the vehicle in the simulator viewport with ui.CollapsableFrame("Viewport Camera"): with ui.VStack(spacing=8): ui.Spacer(height=0) # Iterate over the position and rotation menus with ui.HStack(): with ui.HStack(): ui.Label("Position", name="transform", width=50, height=20) ui.Spacer() # Fields X, Y and Z for axis, default_value in zip(all_axis, default_values): with ui.HStack(): with ui.ZStack(width=15): ui.Rectangle( width=15, height=20, style={ "background_color": colors[axis], "border_radius": 3, "corner_flag": ui.CornerFlag.LEFT, }, ) ui.Label(axis, height=20, name="transform_label", alignment=ui.Alignment.CENTER) float_drag = ui.FloatDrag(name="transform", min=-1000000, max=1000000, step=0.01) float_drag.model.set_value(default_value) # Save the model of each FloatDrag such that we can access its values later on self._camera_transform_models.append(float_drag.model) ui.Circle( name="transform", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED ) # Iterate over the position and rotation menus with ui.HStack(): with ui.HStack(): ui.Label("Target", name="transform", width=50, height=20) ui.Spacer() # Fields X, Y and Z for axis, default_value in zip(all_axis, target_default_values): with ui.HStack(): with ui.ZStack(width=15): ui.Rectangle( width=15, height=20, style={ "background_color": colors[axis], "border_radius": 3, "corner_flag": ui.CornerFlag.LEFT, }, ) ui.Label(axis, height=20, name="transform_label", alignment=ui.Alignment.CENTER) float_drag = ui.FloatDrag(name="transform", min=-1000000, max=1000000, step=0.01) float_drag.model.set_value(default_value) # Save the model of each FloatDrag such that we can access its values later on self._camera_transform_models.append(float_drag.model) ui.Circle( name="transform", width=20, height=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED ) # Button to set the camera view ui.Button( "Set Camera Pose", height=WidgetWindow.BUTTON_HEIGHT, clicked_fn=self._delegate.on_set_viewport_camera, style=WidgetWindow.BUTTON_BASE_STYLE, ) ui.Spacer() def _transform_frame(self): """ Method that implements a transform frame to translate and rotate an object that is about to be spawned """ components = ["Position", "Rotation"] all_axis = ["X", "Y", "Z"] colors = {"X": 0xFF5555AA, "Y": 0xFF76A371, "Z": 0xFFA07D4F} default_values = [0.0, 0.0, 0.1] with ui.CollapsableFrame("Position and Orientation"): with ui.VStack(spacing=8): ui.Spacer(height=0) # Iterate over the position and rotation menus for component in components: with ui.HStack(): with ui.HStack(): ui.Label(component, name="transform", width=50) ui.Spacer() # Fields X, Y and Z for axis, default_value in zip(all_axis, default_values): with ui.HStack(): with ui.ZStack(width=15): ui.Rectangle( width=15, height=20, style={ "background_color": colors[axis], "border_radius": 3, "corner_flag": ui.CornerFlag.LEFT, }, ) ui.Label(axis, name="transform_label", alignment=ui.Alignment.CENTER) if component == "Position": float_drag = ui.FloatDrag(name="transform", min=-1000000, max=1000000, step=0.01) float_drag.model.set_value(default_value) else: float_drag = ui.FloatDrag(name="transform", min=-180.0, max=180.0, step=0.01) # Save the model of each FloatDrag such that we can access its values later on self._vehicle_transform_models.append(float_drag.model) ui.Circle(name="transform", width=20, radius=3.5, size_policy=ui.CircleSizePolicy.FIXED) ui.Spacer(height=0) # ------------------------------------------------------------------------------------------------ # TODO - optimize the reading of values from the transform widget. This could be one function only # ------------------------------------------------------------------------------------------------ def get_selected_vehicle_attitude(self): # Extract the vehicle desired position and orientation for spawning if len(self._vehicle_transform_models) == 6: vehicle_pos = np.array([self._vehicle_transform_models[i].get_value_as_float() for i in range(3)]) vehicel_orientation = np.array( [self._vehicle_transform_models[i].get_value_as_float() for i in range(3, 6)] ) return vehicle_pos, vehicel_orientation return None, None def get_selected_camera_pos(self): """ Method that returns the currently selected camera position in the camera transform widget """ # Extract the camera desired position and the target it is pointing to if len(self._camera_transform_models) == 6: camera_pos = np.array([self._camera_transform_models[i].get_value_as_float() for i in range(3)]) camera_target = np.array([self._camera_transform_models[i].get_value_as_float() for i in range(3, 6)]) return camera_pos, camera_target return None, None	22,406	Python	48.030634	169	0.512407
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/ui/ui_delegate.py	""" | File: ui_delegate.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of the UiDelegate which is an abstraction layer betweeen the extension UI and code logic features """ # External packages import os import asyncio from scipy.spatial.transform import Rotation # Omniverse extensions import carb import omni.ui as ui # Extension Configurations from pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface # Vehicle Manager to spawn Vehicles from pegasus.simulator.logic.backends import MavlinkBackend, MavlinkBackendConfig #, ROS2Backend from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig from pegasus.simulator.logic.vehicle_manager import VehicleManager class UIDelegate: """ Object that will interface between the logic/dynamic simulation part of the extension and the Widget UI """ def __init__(self): # The window that will be bound to this delegate self._window = None # Get an instance of the pegasus simulator self._pegasus_sim: PegasusInterface = PegasusInterface() # Attribute that holds the currently selected scene from the dropdown menu self._scene_dropdown: ui.AbstractItemModel = None self._scene_names = list(SIMULATION_ENVIRONMENTS.keys()) # Selected latitude, longitude and altitude self._latitude_field: ui.AbstractValueModel = None self._latitude = PegasusInterface().latitude self._longitude_field: ui.AbstractValueModel = None self._longitude = PegasusInterface().longitude self._altitude_field: ui.AbstractValueModel = None self._altitude = PegasusInterface().altitude # Attribute that hold the currently selected vehicle from the dropdown menu self._vehicle_dropdown: ui.AbstractItemModel = None self._vehicles_names = list(ROBOTS.keys()) # Get an instance of the vehicle manager self._vehicle_manager = VehicleManager() # Selected option for broadcasting the simulated vehicle (PX4+ROS2 or just ROS2) # By default we assume PX4 self._streaming_backend: str = "px4" # Selected value for the the id of the vehicle self._vehicle_id_field: ui.AbstractValueModel = None self._vehicle_id: int = 0 # Attribute that will save the model for the px4-autostart checkbox self._px4_autostart_checkbox: ui.AbstractValueModel = None self._autostart_px4: bool = True # Atributes to store the path for the Px4 directory self._px4_directory_field: ui.AbstractValueModel = None self._px4_dir: str = PegasusInterface().px4_path # Atributes to store the PX4 airframe self._px4_airframe_field: ui.AbstractValueModel = None self._px4_airframe: str = self._pegasus_sim.px4_default_airframe def set_window_bind(self, window): self._window = window def set_scene_dropdown(self, scene_dropdown_model: ui.AbstractItemModel): self._scene_dropdown = scene_dropdown_model def set_latitude_field(self, latitude_model: ui.AbstractValueModel): self._latitude_field = latitude_model def set_longitude_field(self, longitude_model: ui.AbstractValueModel): self._longitude_field = longitude_model def set_altitude_field(self, altitude_model: ui.AbstractValueModel): self._altitude_field = altitude_model def set_vehicle_dropdown(self, vehicle_dropdown_model: ui.AbstractItemModel): self._vehicle_dropdown = vehicle_dropdown_model def set_vehicle_id_field(self, vehicle_id_field: ui.AbstractValueModel): self._vehicle_id_field = vehicle_id_field def set_streaming_backend(self, backend: str = "px4"): carb.log_info("Chosen option: " + backend) self._streaming_backend = backend def set_px4_autostart_checkbox(self, checkbox_model:ui.AbstractValueModel): self._px4_autostart_checkbox = checkbox_model def set_px4_directory_field(self, directory_field_model: ui.AbstractValueModel): self._px4_directory_field = directory_field_model def set_px4_airframe_field(self, airframe_field_model: ui.AbstractValueModel): self._px4_airframe_field = airframe_field_model """ --------------------------------------------------------------------- Callbacks to handle user interaction with the extension widget window --------------------------------------------------------------------- """ def on_load_scene(self): """ Method that should be invoked when the button to load the selected world is pressed """ # Check if a scene is selected in the drop-down menu if self._scene_dropdown is not None: # Get the id of the selected environment from the list environemnt_index = self._scene_dropdown.get_item_value_model().as_int # Get the name of the selected world selected_world = self._scene_names[environemnt_index] # Try to spawn the selected world asyncio.ensure_future(self._pegasus_sim.load_environment_async(SIMULATION_ENVIRONMENTS[selected_world], force_clear=True)) def on_set_new_global_coordinates(self): """ Method that gets invoked to set new global coordinates for this simulation """ self._pegasus_sim.set_global_coordinates( self._latitude_field.get_value_as_float(), self._longitude_field.get_value_as_float(), self._altitude_field.get_value_as_float()) def on_reset_global_coordinates(self): """ Method that gets invoked to set the global coordinates to the defaults saved in the extension configuration file """ self._pegasus_sim.set_default_global_coordinates() self._latitude_field.set_value(self._pegasus_sim.latitude) self._longitude_field.set_value(self._pegasus_sim.longitude) self._altitude_field.set_value(self._pegasus_sim.altitude) def on_set_new_default_global_coordinates(self): """ Method that gets invoked to set new defualt global coordinates for this simulation. This will attempt to save the current coordinates as new defaults for the extension itself """ self._pegasus_sim.set_new_default_global_coordinates( self._latitude_field.get_value_as_float(), self._longitude_field.get_value_as_float(), self._altitude_field.get_value_as_float() ) def on_clear_scene(self): """ Method that should be invoked when the clear world button is pressed """ self._pegasus_sim.clear_scene() def on_load_vehicle(self): """ Method that should be invoked when the button to load the selected vehicle is pressed """ async def async_load_vehicle(): # Check if we already have a physics environment activated. If not, then activate it # and only after spawn the vehicle. This is to avoid trying to spawn a vehicle without a physics # environment setup. This way we can even spawn a vehicle in an empty world and it won't care if hasattr(self._pegasus_sim.world, "_physics_context") == False: await self._pegasus_sim.world.initialize_simulation_context_async() # Check if a vehicle is selected in the drop-down menu if self._vehicle_dropdown is not None and self._window is not None: # Get the id of the selected vehicle from the list vehicle_index = self._vehicle_dropdown.get_item_value_model().as_int # Get the name of the selected vehicle selected_robot = self._vehicles_names[vehicle_index] # Get the id of the selected vehicle self._vehicle_id = self._vehicle_id_field.get_value_as_int() # Get the desired position and orientation of the vehicle from the UI transform pos, euler_angles = self._window.get_selected_vehicle_attitude() # Read if we should auto-start px4 from the checkbox px4_autostart = self._px4_autostart_checkbox.get_value_as_bool() # Read the PX4 path from the field px4_path = os.path.expanduser(self._px4_directory_field.get_value_as_string()) # Read the PX4 airframe from the field px4_airframe = self._px4_airframe_field.get_value_as_string() # Create the multirotor configuration mavlink_config = MavlinkBackendConfig({ "vehicle_id": self._vehicle_id, "px4_autolaunch": px4_autostart, "px4_dir": px4_path, "px4_vehicle_model": px4_airframe }) config_multirotor = MultirotorConfig() config_multirotor.backends = [MavlinkBackend(mavlink_config)] #ros2 = ROS2Backend(self._vehicle_id) # Try to spawn the selected robot in the world to the specified namespace Multirotor( "/World/quadrotor", ROBOTS[selected_robot], self._vehicle_id, pos, Rotation.from_euler("XYZ", euler_angles, degrees=True).as_quat(), config=config_multirotor, ) # Log that a vehicle of the type multirotor was spawned in the world via the extension UI carb.log_info("Spawned the robot: " + selected_robot + " using the Pegasus Simulator UI") else: # Log that it was not possible to spawn the vehicle in the world using the Pegasus Simulator UI carb.log_error("Could not spawn the robot using the Pegasus Simulator UI") # Run the actual vehicle spawn async so that the UI does not freeze asyncio.ensure_future(async_load_vehicle()) def on_set_viewport_camera(self): """ Method that should be invoked when the button to set the viewport camera pose is pressed """ carb.log_warn("The viewport camera pose has been adjusted") if self._window: # Get the current camera position value camera_position, camera_target = self._window.get_selected_camera_pos() if camera_position is not None and camera_target is not None: # Set the camera view to a fixed value self._pegasus_sim.set_viewport_camera(eye=camera_position, target=camera_target) def on_set_new_default_px4_path(self): """ Method that will try to update the new PX4 autopilot path with whatever is passed on the string field """ carb.log_warn("A new default PX4 Path will be set for the extension.") # Read the current path from the field path = self._px4_directory_field.get_value_as_string() # Set the path using the pegasus interface self._pegasus_sim.set_px4_path(path) def on_reset_px4_path(self): """ Method that will reset the string field to the default PX4 path """ carb.log_warn("Reseting the path to the default one") self._px4_directory_field.set_value(self._pegasus_sim.px4_path)	11,596	Python	41.324817	134	0.643412
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/ui/__init__.py	# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause from .ui_delegate import UIDelegate from .ui_window import WidgetWindow	175	Python	24.142854	39	0.777143
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicle_manager.py	""" | File: vehicle_manager.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of the VehicleManager class - a singleton used to manage the vehiles that are spawned in the simulation world """ __all__ = ["VehicleManager"] import carb from threading import Lock class VehicleManager: """The VehicleManager class is implemented following a singleton pattern. This means that once a vehicle is spawned on the world or an instance of the VehicleManager is created, no either will be running at the same time. This class keeps track of all the vehicles that are spawned in the simulation world, either trough the extension UI or via Python script. Every time a new vehicle object is created, the 'add_vehicle' method is invoked. Additionally, a vehicle is removed, i.e. 'remove_vehicle' gets invoked, every time the '__del__' function of the "Vehicle" object gets invoked. """ # The object instance of the Vehicle Manager _instance = None _is_initialized = False # A dictionary of vehicles that are spawned in the simulator _vehicles = {} # Lock for safe multi-threading _lock: Lock = Lock() def __init__(self): """ Constructor for the vehicle manager class. """ pass """ Properties """ @property def vehicles(self): """ Returns: (list) List of vehicles that were spawned. """ return VehicleManager._vehicles """ Operations """ @staticmethod def get_vehicle_manager(): """ Method that returns the current vehicle manager. """ return VehicleManager() def add_vehicle(self, stage_prefix: str, vehicle): """ Method that adds the vehicles to the vehicle manager. Args: stage_prefix (str): A string with the name that the vehicle is spawned in the simulator vehicle (Vehicle): The vehicle object being added to the vehicle manager. """ VehicleManager._vehicles[stage_prefix] = vehicle def get_vehicle(self, stage_prefix: str): """Method that returns the vehicle object given its stage prefix. Returns None if there is no vehicle associated with that stage prefix Args: stage_prefix (str): A string with the name that the vehicle is spawned in the simulator Returns: Vehicle: The vehicle object associated with the stage_prefix """ return VehicleManager._vehicles.get(stage_prefix, None) def remove_vehicle(self, stage_prefix: str): """ Method that deletes a vehicle from the vehicle manager. Args: stage_prefix (str): A string with the name that the vehicle is spawned in the simulator. """ try: VehicleManager._vehicles.pop(stage_prefix) except: pass def remove_all_vehicles(self): """ Method that will delete all the vehicles that were spawned from the vehicle manager. """ VehicleManager._vehicles.clear() def __new__(cls): """Method that allocated memory for a new vehicle_manager. Since the VehicleManager follows a singleton pattern, only one instance of VehicleManger object can be in memory at any time. Returns: VehicleManger: the single instance of the VehicleManager class. """ # Use a lock in here to make sure we do not have a race condition # when using multi-threading and creating the first instance of the VehicleManager with cls._lock: if cls._instance is None: cls._instance = object.__new__(cls) else: carb.log_info("Vehicle Manager is defined already, returning the previously defined one") return VehicleManager._instance def __del__(self): """Destructor for the object""" VehicleManager._instance = None return	4,124	Python	31.738095	135	0.640883
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/state.py	""" | File: state.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Describes the state of a vehicle (or rigidbody). """ __all__ = ["State"] import numpy as np from scipy.spatial.transform import Rotation from pegasus.simulator.logic.rotations import rot_ENU_to_NED, rot_FLU_to_FRD class State: """ Stores the state of a given vehicle. Note: - position - A numpy array with the [x,y,z] of the vehicle expressed in the inertial frame according to an ENU convention. - orientation - A numpy array with the quaternion [qx, qy, qz, qw] that encodes the attitude of the vehicle's FLU body frame, relative to an ENU inertial frame, expressed in the ENU inertial frame. - linear_velocity - A numpy array with [vx,vy,vz] that defines the velocity of the vehicle expressed in the inertial frame according to an ENU convention. - linear_body_velocity - A numpy array with [u,v,w] that defines the velocity of the vehicle expressed in the FLU body frame. - angular_velocity - A numpy array with [p,q,r] with the angular velocity of the vehicle's FLU body frame, relative to an ENU inertial frame, expressed in the FLU body frame. - linear acceleration - An array with [x_ddot, y_ddot, z_ddot] with the acceleration of the vehicle expressed in the inertial frame according to an ENU convention. """ def __init__(self): """ Initialize the State object """ # The position [x,y,z] of the vehicle's body frame relative to the inertial frame, expressed in the inertial frame self.position = np.array([0.0, 0.0, 0.0]) # The attitude (orientation) of the vehicle's body frame relative to the inertial frame of reference, # expressed in the inertial frame. This quaternion should follow the convention [qx, qy, qz, qw], such that "no rotation" # equates to the quaternion=[0, 0, 0, 1] self.attitude = np.array([0.0, 0.0, 0.0, 1.0]) # The linear velocity [u,v,w] of the vehicle's body frame expressed in the body frame of reference self.linear_body_velocity = np.array([0.0, 0.0, 0.0]) # The linear velocity [x_dot, y_dot, z_dot] of the vehicle's body frame expressed in the inertial frame of reference self.linear_velocity = np.array([0.0, 0.0, 0.0]) # The angular velocity [wx, wy, wz] of the vehicle's body frame relative to the inertial frame, expressed in the body frame self.angular_velocity = np.array([0.0, 0.0, 0.0]) # The linear acceleration [ax, ay, az] of the vehicle's body frame relative to the inertial frame, expressed in the inertial frame self.linear_acceleration = np.array([0.0, 0.0, 0.0]) def get_position_ned(self): """ Method that, assuming that a state is encoded in ENU standard (the Isaac Sim standard), converts the position to the NED convention used by PX4 and other onboard flight controllers Returns: np.ndarray: A numpy array with the [x,y,z] of the vehicle expressed in the inertial frame according to an NED convention. """ return rot_ENU_to_NED.apply(self.position) def get_attitude_ned_frd(self): """ Method that, assuming that a state is encoded in ENU-FLU standard (the Isaac Sim standard), converts the attitude of the vehicle it to the NED-FRD convention used by PX4 and other onboard flight controllers Returns: np.ndarray: A numpy array with the quaternion [qx, qy, qz, qw] that encodes the attitude of the vehicle's FRD body frame, relative to an NED inertial frame, expressed in the NED inertial frame. """ attitude_frd_ned = rot_ENU_to_NED * Rotation.from_quat(self.attitude) * rot_FLU_to_FRD return attitude_frd_ned.as_quat() def get_linear_body_velocity_ned_frd(self): """ Method that, assuming that a state is encoded in ENU-FLU standard (the Isaac Sim standard), converts the linear body velocity of the vehicle it to the NED-FRD convention used by PX4 and other onboard flight controllers Returns: np.ndarray: A numpy array with [u,v,w] that defines the velocity of the vehicle expressed in the FRD body frame. """ # Get the linear acceleration in FLU convention linear_acc_body_flu = Rotation.from_quat(self.attitude).inv().apply(self.linear_acceleration) # Convert the linear acceleration in the body frame expressed in FLU convention to the FRD convention return rot_FLU_to_FRD.apply(linear_acc_body_flu) def get_linear_velocity_ned(self): """ Method that, assuming that a state is enconded in ENU-FLU standard (the Isaac Sim standard), converts the linear velocity expressed in the inertial frame to the NED convention used by PX4 and other onboard flight controllers Returns: np.ndarray: A numpy array with [vx,vy,vz] that defines the velocity of the vehicle expressed in the inertial frame according to a NED convention. """ return rot_ENU_to_NED.apply(self.linear_velocity) def get_angular_velocity_frd(self): """ Method that, assuming that a state is enconded in ENU-FLU standard (the Isaac Sim standard), converts the angular velocity expressed in the body frame to the NED-FRD convention used by PX4 and other onboard flight controllers Returns: np.ndarray: A numpy array with [p,q,r] with the angular velocity of the vehicle's FRD body frame, relative to an NED inertial frame, expressed in the FRD body frame. """ return rot_FLU_to_FRD.apply(self.angular_velocity) def get_linear_acceleration_ned(self): """ Method that, assuming that a state is enconded in ENU-FLU standard (the Isaac Sim standard), converts the linear acceleration expressed in the inertial frame to the NED convention used by PX4 and other onboard flight controllers Returns: np.ndarray: An array with [x_ddot, y_ddot, z_ddot] with the acceleration of the vehicle expressed in the inertial frame according to an NED convention. """ return rot_ENU_to_NED.apply(self.linear_acceleration)	6,384	Python	52.208333	205	0.684211
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/__init__.py	""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .interface.pegasus_interface import PegasusInterface	212	Python	34.499994	82	0.768868
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/rotations.py	""" | File: rotations.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Implements utilitary rotations between ENU and NED inertial frame conventions and FLU and FRD body frame conventions. """ import numpy as np from scipy.spatial.transform import Rotation # Quaternion for rotation between ENU and NED INERTIAL frames # NED to ENU: +PI/2 rotation about Z (Down) followed by a +PI rotation around X (old North/new East) # ENU to NED: +PI/2 rotation about Z (Up) followed by a +PI rotation about X (old East/new North) # This rotation is symmetric, so q_ENU_to_NED == q_NED_to_ENU. # Note: this quaternion follows the convention [qx, qy, qz, qw] q_ENU_to_NED = np.array([0.70711, 0.70711, 0.0, 0.0]) # A scipy rotation from the ENU inertial frame to the NED inertial frame of reference rot_ENU_to_NED = Rotation.from_quat(q_ENU_to_NED) # Quaternion for rotation between body FLU and body FRD frames # +PI rotation around X (Forward) axis rotates from Forward, Right, Down (aircraft) # to Forward, Left, Up (base_link) frames and vice-versa. # This rotation is symmetric, so q_FLU_to_FRD == q_FRD_to_FLU. # Note: this quaternion follows the convention [qx, qy, qz, qw] q_FLU_to_FRD = np.array([1.0, 0.0, 0.0, 0.0]) # A scipe rotation from the FLU body frame to the FRD body frame rot_FLU_to_FRD = Rotation.from_quat(q_FLU_to_FRD)	1,447	Python	48.931033	132	0.735314
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/__init__.py	""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .thrust_curve import ThrustCurve from .quadratic_thrust_curve import QuadraticThrustCurve	249	Python	34.714281	82	0.779116
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/quadratic_thrust_curve.py	""" | File: quadratic_thrust_curve.py | Author: Marcelo Jacinto ([email protected]) | Descriptio: File that implements a quadratic thrust curve for rotors | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ import numpy as np from pegasus.simulator.logic.state import State from pegasus.simulator.logic.thrusters.thrust_curve import ThrustCurve class QuadraticThrustCurve(ThrustCurve): """Class that implements the dynamics of rotors that can be described by a quadratic thrust curve """ def __init__(self, config={}): """_summary_ Args: config (dict): A Dictionary that contains all the parameters for configuring the QuadraticThrustCurve - it can be empty or only have some of the parameters used by the QuadraticThrustCurve. Examples: The dictionary default parameters are >>> {"num_rotors": 4, >>> "rotor_constant": [5.84e-6, 5.84e-6, 5.84e-6, 5.84e-6], >>> "rolling_moment_coefficient": [1e-6, 1e-6, 1e-6, 1e-6], >>> "rot_dir": [-1, -1, 1, 1], >>> "min_rotor_velocity": [0, 0, 0, 0], # rad/s >>> "max_rotor_velocity": [1100, 1100, 1100, 1100], # rad/s >>> } """ # Get the total number of rotors to simulate self._num_rotors = config.get("num_rotors", 4) # The rotor constant used for computing the total thrust produced by the rotor: T = rotor_constant * omega^2 self._rotor_constant = config.get("rotor_constant", [8.54858e-6, 8.54858e-6, 8.54858e-6, 8.54858e-6]) assert len(self._rotor_constant) == self._num_rotors # The rotor constant used for computing the total torque generated about the vehicle Z-axis self._rolling_moment_coefficient = config.get("rolling_moment_coefficient", [1e-6, 1e-6, 1e-6, 1e-6]) assert len(self._rolling_moment_coefficient) == self._num_rotors # Save the rotor direction of rotation self._rot_dir = config.get("rot_dir", [-1, -1, 1, 1]) assert len(self._rot_dir) == self._num_rotors # Values for the minimum and maximum rotor velocity in rad/s self.min_rotor_velocity = config.get("min_rotor_velocity", [0, 0, 0, 0]) assert len(self.min_rotor_velocity) == self._num_rotors self.max_rotor_velocity = config.get("max_rotor_velocity", [1100, 1100, 1100, 1100]) assert len(self.max_rotor_velocity) == self._num_rotors # The actual speed references to apply to the vehicle rotor joints self._input_reference = [0.0 for i in range(self._num_rotors)] # The actual velocity that each rotor is spinning at self._velocity = [0.0 for i in range(self._num_rotors)] # The actual force that each rotor is generating self._force = [0.0 for i in range(self._num_rotors)] # The actual rolling moment that is generated on the body frame of the vehicle self._rolling_moment = 0.0 def set_input_reference(self, input_reference): """ Receives as input a list of target angular velocities of each rotor in rad/s """ # The target angular velocity of the rotor self._input_reference = input_reference def update(self, state: State, dt: float): """ Note: the state and dt variables are not used in this implementation, but left to add support to other rotor models where the total thrust is dependent on states such as vehicle linear velocity Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). """ rolling_moment = 0.0 # Compute the actual force to apply to the rotors and the rolling moment contribution for i in range(self._num_rotors): # Set the actual velocity that each rotor is spinning at (instanenous model - no delay introduced) # Only apply clipping of the input reference self._velocity[i] = np.maximum( self.min_rotor_velocity[i], np.minimum(self._input_reference[i], self.max_rotor_velocity[i]) ) # Set the force using a quadratic thrust curve self._force[i] = self._rotor_constant[i] * np.power(self._velocity[i], 2) # Compute the rolling moment coefficient rolling_moment += self._rolling_moment_coefficient[i] * np.power(self._velocity[i], 2.0) * self._rot_dir[i] # Update the rolling moment variable self._rolling_moment = rolling_moment # Return the forces and velocities on each rotor and total torque applied on the body frame return self._force, self._velocity, self._rolling_moment @property def force(self): """The force to apply to each rotor of the vehicle at any given time instant Returns: list: A list of forces (in Newton N) to apply to each rotor of the vehicle (on its Z-axis) at any given time instant """ return self._force @property def velocity(self): """The velocity at which each rotor of the vehicle should be rotating at any given time instant Returns: list: A list of angular velocities (in rad/s) of each rotor (about its Z-axis) at any given time instant """ return self._velocity @property def rolling_moment(self): """The total rolling moment being generated on the body frame of the vehicle by the rotating propellers Returns: float: The total rolling moment to apply to the vehicle body frame (Torque about the Z-axis) in Nm """ return self._rolling_moment @property def rot_dir(self): """The direction of rotation of each rotor of the vehicle Returns: list(int): A list with the rotation direction of each rotor (-1 is counter-clockwise and 1 for clockwise) """ return self._rot_dir	6,097	Python	41.643356	201	0.632606
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/thrusters/thrust_curve.py	""" | File: thrust_curve.py | Author: Marcelo Jacinto ([email protected]) | Descriptio: File that implements the base interface for defining thrust curves for vehicles | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from pegasus.simulator.logic.state import State class ThrustCurve: """Class that implements the dynamics of rotors that can be described by a quadratic thrust curve """ def __init__(self): pass def set_input_reference(self, input_reference): """ Receives as input a list of target angular velocities of each rotor in rad/s """ pass def update(self, state: State, dt: float): """ Note: the state and dt variables are not used in this implementation, but left to add support to other rotor models where the total thrust is dependent on states such as vehicle linear velocity Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). """ pass @property def force(self): """The force to apply to each rotor of the vehicle at any given time instant Returns: list: A list of forces (in Newton N) to apply to each rotor of the vehicle (on its Z-axis) at any given time instant """ pass @property def velocity(self): """The velocity at which each rotor of the vehicle should be rotating at any given time instant Returns: list: A list of angular velocities (in rad/s) of each rotor (about its Z-axis) at any given time instant """ pass @property def rolling_moment(self): """The total rolling moment being generated on the body frame of the vehicle by the rotating propellers Returns: float: The total rolling moment to apply to the vehicle body frame (Torque about the Z-axis) in Nm """ pass @property def rot_dir(self): """The direction of rotation of each rotor of the vehicle Returns: list(int): A list with the rotation direction of each rotor (-1 is counter-clockwise and 1 for clockwise) """ pass	2,307	Python	32.941176	128	0.642826
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/ros2_camera.py	""" | File: ros2_camera.py | License: BSD-3-Clause. Copyright (c) 2023, Micah Nye. All rights reserved. """ __all__ = ["ROS2Camera"] import carb from omni.isaac.core.utils import stage import omni.graph.core as og from omni.isaac.core.utils.prims import is_prim_path_valid from omni.isaac.core.utils.prims import set_targets from pegasus.simulator.logic.graphs import Graph from pegasus.simulator.logic.vehicles import Vehicle import numpy as np class ROS2Camera(Graph): """The class that implements the ROS2 Camera graph. This class inherits the base class Graph. """ def __init__(self, camera_prim_path: str, config: dict = {}): """Initialize the ROS2 Camera class Args: camera_prim_path (str): Path to the camera prim. Global path when it starts with `/`, else local to vehicle prim path config (dict): A Dictionary that contains all the parameters for configuring the ROS2Camera - it can be empty or only have some of the parameters used by the ROS2Camera. Examples: The dictionary default parameters are >>> {"graph_evaluator": "execution", # type of the omnigraph to create (execution, push) >>> "resolution": [640, 480], # output video stream resolution in pixels [width, height] >>> "types": ['rgb', 'camera_info'], # rgb, depth, depth_pcl, instance_segmentation, semantic_segmentation, bbox_2d_tight, bbox_2d_loose, bbox_3d, camera_info >>> "publish_labels": True, # publish labels for instance_segmentation, semantic_segmentation, bbox_2d_tight, bbox_2d_loose and bbox_3d camera types >>> "topic": "" # base topic name for the camera (default is camera name in Isaac Sim) >>> "namespace": "" # namespace for the camera (default is vehicle name in Isaac Sim) >>> "tf_frame_id": ""} # tf frame id for the camera (default is camera name in Isaac Sim) """ # Initialize the Super class "object" attribute super().__init__(graph_type="ROS2Camera") # Save camera path, frame id and ros topic name self._camera_prim_path = camera_prim_path self._frame_id = camera_prim_path.rpartition("/")[-1] # frame_id of the camera is the last prim path part after `/` self._base_topic = config.get("topic", "") self._namespace = config.get("namespace", "") self._tf_frame_id = config.get("tf_frame_id", "") # Process the config dictionary self._graph_evaluator = config.get("graph_evaluator", "execution") self._resolution = config.get("resolution", [640, 480]) self._types = np.array(config.get("types", ['rgb', 'camera_info'])) self._publish_labels = config.get("publish_labels", True) def initialize(self, vehicle: Vehicle): """Method that initializes the graph of the camera. Args: vehicle (Vehicle): The vehicle that this graph is attached to. """ # Set the namespace for the camera if non is provided if self._namespace == "": self._namespace = f"/{vehicle.vehicle_name}" # Set the base topic for the camera if non is provided if self._base_topic == "": self._base_topic = f"/{self._frame_id}" # Set the tf frame id for the camera if non is provided if self._tf_frame_id == "": self._tf_frame_id = self._frame_id # Set the prim_path for the camera if self._camera_prim_path[0] != '/': self._camera_prim_path = f"{vehicle.prim_path}/{self._camera_prim_path}" # Create camera prism if not is_prim_path_valid(self._camera_prim_path): carb.log_error(f"Cannot create ROS2 Camera graph, the camera prim path \"{self._camera_prim_path}\" is not valid") return # Set the prim paths for camera and tf graphs graph_path = f"{self._camera_prim_path}_pub" # Graph configuration if self._graph_evaluator == "execution": graph_specs = { "graph_path": graph_path, "evaluator_name": "execution", } elif self._graph_evaluator == "push": graph_specs = { "graph_path": graph_path, "evaluator_name": "push", "pipeline_stage": og.GraphPipelineStage.GRAPH_PIPELINE_STAGE_ONDEMAND, } else: carb.log_error(f"Cannot create ROS2 Camera graph, graph evaluator type \"{self._graph_evaluator}\" is not valid") return # Creating a graph edit configuration with cameraHelper nodes to generate ROS image publishers keys = og.Controller.Keys graph_config = { keys.CREATE_NODES: [ ("on_tick", "omni.graph.action.OnTick"), ("create_viewport", "omni.isaac.core_nodes.IsaacCreateViewport"), ("get_render_product", "omni.isaac.core_nodes.IsaacGetViewportRenderProduct"), ("set_viewport_resolution", "omni.isaac.core_nodes.IsaacSetViewportResolution"), ("set_camera", "omni.isaac.core_nodes.IsaacSetCameraOnRenderProduct"), ], keys.CONNECT: [ ("on_tick.outputs:tick", "create_viewport.inputs:execIn"), ("create_viewport.outputs:execOut", "get_render_product.inputs:execIn"), ("create_viewport.outputs:viewport", "get_render_product.inputs:viewport"), ("create_viewport.outputs:execOut", "set_viewport_resolution.inputs:execIn"), ("create_viewport.outputs:viewport", "set_viewport_resolution.inputs:viewport"), ("set_viewport_resolution.outputs:execOut", "set_camera.inputs:execIn"), ("get_render_product.outputs:renderProductPath", "set_camera.inputs:renderProductPath"), ], keys.SET_VALUES: [ ("create_viewport.inputs:viewportId", 0), ("create_viewport.inputs:name", f"{self._namespace}/{self._frame_id}"), ("set_viewport_resolution.inputs:width", self._resolution[0]), ("set_viewport_resolution.inputs:height", self._resolution[1]), ], } # Add camerasHelper for each selected camera type valid_camera_type = False for camera_type in self._types: if not camera_type in ["rgb", "depth", "depth_pcl", "semantic_segmentation", "instance_segmentation", "bbox_2d_tight", "bbox_2d_loose", "bbox_3d", "camera_info"]: continue camera_helper_name = f"camera_helper_{camera_type}" graph_config[keys.CREATE_NODES] += [ (camera_helper_name, "omni.isaac.ros2_bridge.ROS2CameraHelper") ] graph_config[keys.CONNECT] += [ ("set_camera.outputs:execOut", f"{camera_helper_name}.inputs:execIn"), ("get_render_product.outputs:renderProductPath", f"{camera_helper_name}.inputs:renderProductPath") ] graph_config[keys.SET_VALUES] += [ (f"{camera_helper_name}.inputs:nodeNamespace", self._namespace), (f"{camera_helper_name}.inputs:frameId", self._tf_frame_id), (f"{camera_helper_name}.inputs:topicName", f"{self._base_topic}/{camera_type}"), (f"{camera_helper_name}.inputs:type", camera_type) ] # Publish labels for specific camera types if self._publish_labels and camera_type in ["semantic_segmentation", "instance_segmentation", "bbox_2d_tight", "bbox_2d_loose", "bbox_3d"]: graph_config[keys.SET_VALUES] += [ (camera_helper_name + ".inputs:enableSemanticLabels", True), (camera_helper_name + ".inputs:semanticLabelsTopicName", f"{self._frame_id}/{camera_type}_labels") ] valid_camera_type = True if not valid_camera_type: carb.log_error(f"Cannot create ROS2 Camera graph, no valid camera type was selected") return # Create the camera graph (graph, _, _, _) = og.Controller.edit( graph_specs, graph_config ) # Connect camera to the graphs set_targets( prim=stage.get_current_stage().GetPrimAtPath(f"{graph_path}/set_camera"), attribute="inputs:cameraPrim", target_prim_paths=[self._camera_prim_path] ) # Run the ROS Camera graph once to generate ROS image publishers in SDGPipeline og.Controller.evaluate_sync(graph) # Also initialize the Super class with updated prim path (only camera graph path) super().initialize(graph_path) def camera_topic(self, camera_type: str) -> str: """ (str) Path to the camera topic. Args: camera_type (str): one of the supported camera output types Returns: Camera topic name (str) if the camera type exists, else empty string """ return f"{self._namespace}{self._base_topic}/{camera_type}" if camera_type in self._types else "" def camera_labels_topic(self, camera_type: str) -> str: """ (str) Path to the camera labels topic. Args: camera_type (str): one of the supported camera output types Returns: Camera labels topic name (str) if the camera type exists, else empty string """ if not self._publish_labels or \ not camera_type in self._types or \ not camera_type in ["semantic_segmentation", "instance_segmentation", "bbox_2d_tight", "bbox_2d_loose", "bbox_3d"]: return "" return f"{self._namespace}{self._base_topic}/{camera_type}_labels"	9,941	Python	45.896226	181	0.5933
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/__init__.py	""" | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved. """ from .graph import Graph from .ros2_camera import ROS2Camera	168	Python	23.142854	97	0.738095
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/graphs/graph.py	""" | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved. """ __all__ = ["Graph"] class Graph: """The base class for implementing OmniGraphs Attributes: graph_prim_path """ def __init__(self, graph_type: str): """Initialize Graph class Args: graph_type (str): A name that describes the type of graph """ self._graph_type = graph_type self._graph_prim_path = None def initialize(self, graph_prim_path: str): """ Method that should be implemented and called by the class that inherits the graph object. """ self._graph_prim_path = graph_prim_path @property def graph_type(self) -> str: """ (str) A name that describes the type of graph. """ return self._graph_type @property def graph_prim_path(self) -> str: """ (str) Path to the graph. """ return self._graph_prim_path	1,011	Python	24.299999	97	0.568744
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/magnetometer.py	""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Simulates a magnetometer. Based on the original implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Elia Tarasov """ __all__ = ["Magnetometer"] import numpy as np from scipy.spatial.transform import Rotation from pegasus.simulator.logic.state import State from pegasus.simulator.logic.sensors import Sensor from pegasus.simulator.logic.rotations import rot_ENU_to_NED, rot_FLU_to_FRD from pegasus.simulator.logic.sensors.geo_mag_utils import ( get_mag_declination, get_mag_inclination, get_mag_strength, reprojection, ) class Magnetometer(Sensor): """The class that implements a magnetometer sensor. This class inherits the base class Sensor. """ def __init__(self, config={}): """Initialize the Magnetometer class Args: config (dict): A Dictionary that contains all the parameters for configuring the Magnetometer - it can be empty or only have some of the parameters used by the Magnetometer. Examples: The dictionary default parameters are >>> {"noise_density": 0.4e-3, # gauss / sqrt(hz) >>> "random_walk": 6.4e-6, # gauss * sqrt(hz) >>> "bias_correlation_time": 6.0e2, # s >>> "update_rate": 250.0} # Hz """ # Initialize the Super class "object" attributes super().__init__(sensor_type="Magnetometer", update_rate=config.get("update_rate", 250.0)) # Set the noise parameters self._bias: np.ndarray = np.array([0.0, 0.0, 0.0]) self._noise_density = config.get("noise_density", 0.4e-3) # gauss / sqrt(hz) self._random_walk = config.get("random_walk", 6.4e-6) # gauss * sqrt(hz) self._bias_correlation_time = config.get("bias_correlation_time", 6.0e2) # s # Initial state measured by the Magnetometer self._state = {"magnetic_field": np.zeros((3,))} @property def state(self): """ (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time """ return self._state @Sensor.update_at_rate def update(self, state: State, dt: float): """Method that implements the logic of a magnetometer. In this method we start by computing the projection of the vehicle body frame such in the elipsoidal model of the earth in order to get its current latitude and longitude. From here the declination and inclination are computed and used to get the strength of the magnetic field, expressed in the inertial frame of reference (in ENU convention). This magnetic field is then rotated to the body frame such that it becomes expressed in a FRD body frame relative to a NED inertial reference frame. (The convention adopted by PX4). Random noise and bias are added to this magnetic field. Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: (dict) A dictionary containing the current state of the sensor (the data produced by the sensor) """ # Get the latitude and longitude from the current state latitude, longitude = reprojection(state.position, np.radians(self._origin_lat), np.radians(self._origin_lon)) # Magnetic declination and inclination (radians) declination_rad: float = np.radians(get_mag_declination(np.degrees(latitude), np.degrees(longitude))) inclination_rad: float = np.radians(get_mag_inclination(np.degrees(latitude), np.degrees(longitude))) # Compute the magnetic strength (10^5xnanoTesla) strength_ga: float = 0.01 * get_mag_strength(np.degrees(latitude), np.degrees(longitude)) # Compute the Magnetic filed components according to: http://geomag.nrcan.gc.ca/mag_fld/comp-en.php H: float = strength_ga * np.cos(inclination_rad) Z: float = np.tan(inclination_rad) * H X: float = H * np.cos(declination_rad) Y: float = H * np.sin(declination_rad) # Magnetic field of a body following a front-left-up (FLU) convention expressed in a East-North-Up (ENU) inertial frame magnetic_field_inertial: np.ndarray = np.array([X, Y, Z]) # Rotate the magnetic field vector such that it expresses a field of a body frame according to the front-right-down (FRD) # expressed in a North-East-Down (NED) inertial frame (the standard used in magnetometer units) attitude_flu_enu = Rotation.from_quat(state.attitude) # Rotate the magnetic field from the inertial frame to the body frame of reference according to the FLU frame convention rot_body_to_world = rot_ENU_to_NED * attitude_flu_enu * rot_FLU_to_FRD.inv() # The magnetic field expressed in the body frame according to the front-right-down (FRD) convention magnetic_field_body = rot_body_to_world.inv().apply(magnetic_field_inertial) # ------------------------------- # Add noise to the magnetic field # ------------------------------- tau = self._bias_correlation_time # Discrete-time standard deviation equivalent to an "integrating" sampler with integration time dt. sigma_d: float = 1 / np.sqrt(dt) * self._noise_density sigma_b: float = self._random_walk # Compute exact covariance of the process after dt [Maybeck 4-114]. sigma_b_d: float = np.sqrt(-sigma_b * sigma_b * tau / 2.0 * (np.exp(-2.0 * dt / tau) - 1.0)) # Compute state-transition. phi_d: float = np.exp(-1.0 / tau * dt) # Add the noise to the magnetic field magnetic_field_noisy: np.ndarray = np.zeros((3,)) for i in range(3): self._bias[i] = phi_d * self._bias[i] + sigma_b_d * np.random.randn() magnetic_field_noisy[i] = magnetic_field_body[i] + sigma_d * np.random.randn() + self._bias[i] # Add the values to the dictionary and return it self._state = {"magnetic_field": [magnetic_field_noisy[0], magnetic_field_noisy[1], magnetic_field_noisy[2]]} return self._state	6,384	Python	48.115384	185	0.649593
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/geo_mag_utils.py	""" | File: geo_mag_utils.py | Description: Provides utilities for computing latitude, longitude, and magnetic strength given the position of the vehicle in the simulated world. These computations and table constants are in agreement with the PX4 stil_gazebo implementation (https://github.com/PX4/PX4-SITL_gazebo). Therefore, PX4 should behave similarly to a gazebo-based simulation. """ import numpy as np # Declare which functions are visible from this file __all__ = ["get_mag_declination", "get_mag_inclination", "get_mag_strength", "reprojection", "GRAVITY_VECTOR"] # -------------------------------------------------------------------- # Magnetic field data from WMM2018 (10^5xnanoTesla (N, E D) n-frame ) # -------------------------------------------------------------------- # Declination data in degrees DECLINATION_TABLE = [ [ 47,46,45,43,42,41,39,37,33,29,23,16,10,4,-1,-6,-10,-15,-20,-27,-34,-42,-49,-56,-62,-67,-72,-74,-75,-73,-61,-22,26,42,47,48,47 ], [ 31,31,31,30,30,30,30,29,27,24,18,11,3,-4,-9,-13,-15,-18,-21,-27,-33,-40,-47,-52,-56,-57,-56,-52,-44,-30,-14,2,14,22,27,30,31 ], [ 22,23,23,23,22,22,22,23,22,19,13,5,-4,-12,-17,-20,-22,-22,-23,-25,-30,-36,-41,-45,-46,-44,-39,-31,-21,-11,-3,4,10,15,19,21,22 ], [ 17,17,17,18,17,17,17,17,16,13,8,-1,-10,-18,-22,-25,-26,-25,-22,-20,-21,-25,-29,-32,-31,-28,-23,-16,-9,-3,0,4,7,11,14,16,17 ], [ 13,13,14,14,14,13,13,12,11,9,3,-5,-14,-20,-24,-25,-24,-21,-17,-12,-9,-11,-14,-17,-18,-16,-12,-8,-3,-0,1,3,6,8,11,12,13 ], [ 11,11,11,11,11,10,10,10,9,6,-0,-8,-15,-21,-23,-22,-19,-15,-10,-5,-2,-2,-4,-7,-9,-8,-7,-4,-1,1,1,2,4,7,9,10,11 ], [ 10,9,9,9,9,9,9,8,7,3,-3,-10,-16,-20,-20,-18,-14,-9,-5,-2,1,2,0,-2,-4,-4,-3,-2,-0,0,0,1,3,5,7,9,10 ], [ 9,9,9,9,9,9,9,8,6,1,-4,-11,-16,-18,-17,-14,-10,-5,-2,-0,2,3,2,0,-1,-2,-2,-1,-0,-1,-1,-1,1,3,6,8,9 ], [ 8,9,9,10,10,10,10,8,5,0,-6,-12,-15,-16,-15,-11,-7,-4,-1,1,3,4,3,2,1,0,-0,-0,-1,-2,-3,-4,-2,0,3,6,8 ], [ 7,9,10,11,12,12,12,9,5,-1,-7,-13,-15,-15,-13,-10,-6,-3,0,2,3,4,4,4,3,2,1,0,-1,-3,-5,-6,-6,-3,0,4,7 ], [ 5,8,11,13,14,15,14,11,5,-2,-9,-15,-17,-16,-13,-10,-6,-3,0,3,4,5,6,6,6,5,4,2,-1,-5,-8,-9,-9,-6,-3,1,5 ], [ 3,8,11,15,17,17,16,12,5,-4,-12,-18,-19,-18,-16,-12,-8,-4,-0,3,5,7,9,10,10,9,7,4,-1,-6,-10,-12,-12,-9,-5,-1,3 ], [ 3,8,12,16,19,20,18,13,4,-8,-18,-24,-25,-23,-20,-16,-11,-6,-1,3,7,11,14,16,17,17,14,8,-0,-8,-13,-15,-14,-11,-7,-2,3 ]] # Inclination data in degrees INCLINATION_TABLE = [ [ -78,-76,-74,-72,-70,-68,-65,-63,-60,-57,-55,-54,-54,-55,-56,-57,-58,-59,-59,-59,-59,-60,-61,-63,-66,-69,-73,-76,-79,-83,-86,-87,-86,-84,-82,-80,-78 ], [ -72,-70,-68,-66,-64,-62,-60,-57,-54,-51,-49,-48,-49,-51,-55,-58,-60,-61,-61,-61,-60,-60,-61,-63,-66,-69,-72,-76,-78,-80,-81,-80,-79,-77,-76,-74,-72 ], [ -64,-62,-60,-59,-57,-55,-53,-50,-47,-44,-41,-41,-43,-47,-53,-58,-62,-65,-66,-65,-63,-62,-61,-63,-65,-68,-71,-73,-74,-74,-73,-72,-71,-70,-68,-66,-64 ], [ -55,-53,-51,-49,-46,-44,-42,-40,-37,-33,-30,-30,-34,-41,-48,-55,-60,-65,-67,-68,-66,-63,-61,-61,-62,-64,-65,-66,-66,-65,-64,-63,-62,-61,-59,-57,-55 ], [ -42,-40,-37,-35,-33,-30,-28,-25,-22,-18,-15,-16,-22,-31,-40,-48,-55,-59,-62,-63,-61,-58,-55,-53,-53,-54,-55,-55,-54,-53,-51,-51,-50,-49,-47,-45,-42 ], [ -25,-22,-20,-17,-15,-12,-10,-7,-3,1,3,2,-5,-16,-27,-37,-44,-48,-50,-50,-48,-44,-41,-38,-38,-38,-39,-39,-38,-37,-36,-35,-35,-34,-31,-28,-25 ], [ -5,-2,1,3,5,8,10,13,16,20,21,19,12,2,-10,-20,-27,-30,-30,-29,-27,-23,-19,-17,-17,-17,-18,-18,-17,-16,-16,-16,-16,-15,-12,-9,-5 ], [ 15,18,21,22,24,26,29,31,34,36,37,34,28,20,10,2,-3,-5,-5,-4,-2,2,5,7,8,7,7,6,7,7,7,6,5,6,8,11,15 ], [ 31,34,36,38,39,41,43,46,48,49,49,46,42,36,29,24,20,19,20,21,23,25,28,30,30,30,29,29,29,29,28,27,25,25,26,28,31 ], [ 43,45,47,49,51,53,55,57,58,59,59,56,53,49,45,42,40,40,40,41,43,44,46,47,47,47,47,47,47,47,46,44,42,41,40,42,43 ], [ 53,54,56,57,59,61,64,66,67,68,67,65,62,60,57,55,55,54,55,56,57,58,59,59,60,60,60,60,60,60,59,57,55,53,52,52,53 ], [ 62,63,64,65,67,69,71,73,75,75,74,73,70,68,67,66,65,65,65,66,66,67,68,68,69,70,70,71,71,70,69,67,65,63,62,62,62 ], [ 71,71,72,73,75,77,78,80,81,81,80,79,77,76,74,73,73,73,73,73,73,74,74,75,76,77,78,78,78,78,77,75,73,72,71,71,71 ]] # Strength data in centi-Tesla STRENGTH_TABLE = [ [ 62,60,58,56,54,52,49,46,43,41,38,36,34,32,31,31,30,30,30,31,33,35,38,42,46,51,55,59,62,64,66,67,67,66,65,64,62 ], [ 59,56,54,52,50,47,44,41,38,35,32,29,28,27,26,26,26,25,25,26,28,30,34,39,44,49,54,58,61,64,65,66,65,64,63,61,59 ], [ 54,52,49,47,45,42,40,37,34,30,27,25,24,24,24,24,24,24,24,24,25,28,32,37,42,48,52,56,59,61,62,62,62,60,59,56,54 ], [ 49,47,44,42,40,37,35,33,30,28,25,23,22,23,23,24,25,25,26,26,26,28,31,36,41,46,51,54,56,57,57,57,56,55,53,51,49 ], [ 43,41,39,37,35,33,32,30,28,26,25,23,23,23,24,25,26,28,29,29,29,30,32,36,40,44,48,51,52,52,51,51,50,49,47,45,43 ], [ 38,36,35,33,32,31,30,29,28,27,26,25,24,24,25,26,28,30,31,32,32,32,33,35,38,42,44,46,47,46,45,45,44,43,41,40,38 ], [ 34,33,32,32,31,31,31,30,30,30,29,28,27,27,27,28,29,31,32,33,33,33,34,35,37,39,41,42,43,42,41,40,39,38,36,35,34 ], [ 33,33,32,32,33,33,34,34,35,35,34,33,32,31,30,30,31,32,33,34,35,35,36,37,38,40,41,42,42,41,40,39,37,36,34,33,33 ], [ 34,34,34,35,36,37,39,40,41,41,40,39,37,35,35,34,35,35,36,37,38,39,40,41,42,43,44,45,45,45,43,41,39,37,35,34,34 ], [ 37,37,38,39,41,42,44,46,47,47,46,45,43,41,40,39,39,40,41,41,42,43,45,46,47,48,49,50,50,50,48,46,43,41,39,38,37 ], [ 42,42,43,44,46,48,50,52,53,53,52,51,49,47,45,45,44,44,45,46,46,47,48,50,51,53,54,55,56,55,54,52,49,46,44,43,42 ], [ 48,48,49,50,52,53,55,56,57,57,56,55,53,51,50,49,48,48,48,49,49,50,51,53,55,56,58,59,60,60,58,56,54,52,50,49,48 ], [ 54,54,54,55,56,57,58,58,59,58,58,57,56,54,53,52,51,51,51,51,52,53,54,55,57,58,60,61,62,61,61,59,58,56,55,54,54 ]] SAMPLING_RES = 10.0 SAMPLING_MIN_LAT = -60 # deg SAMPLING_MAX_LAT = 60 # deg SAMPLING_MIN_LON = -180 # deg SAMPLING_MAX_LON = 180 # deg EARTH_RADIUS = 6353000.0 # meters # Gravity vector expressed in ENU GRAVITY_VECTOR = np.array([0.0, 0.0, -9.80665]) # m/s^2 def get_lookup_table_index(val: int, min: int, max: int): # for the rare case of hitting the bounds exactly # the rounding logic wouldn't fit, so enforce it. # limit to table bounds - required for maxima even when table spans full globe range # limit to (table bounds - 1) because bilinear interpolation requires checking (index + 1) val = np.clip(val, min, max - SAMPLING_RES) return int((-min + val) / SAMPLING_RES) def get_table_data(lat: float, lon: float, table): # If the values exceed valid ranges, return zero as default # as we have no way of knowing what the closest real value # would be. if lat < -90.0 or lat > 90.0 or lon < -180.0 or lon > 180.0: return 0.0 # round down to nearest sampling resolution min_lat = int(lat / SAMPLING_RES) * SAMPLING_RES min_lon = int(lon / SAMPLING_RES) * SAMPLING_RES # find index of nearest low sampling point min_lat_index = get_lookup_table_index(min_lat, SAMPLING_MIN_LAT, SAMPLING_MAX_LAT) min_lon_index = get_lookup_table_index(min_lon, SAMPLING_MIN_LON, SAMPLING_MAX_LON) data_sw = table[min_lat_index][min_lon_index] data_se = table[min_lat_index][min_lon_index + 1] data_ne = table[min_lat_index + 1][min_lon_index + 1] data_nw = table[min_lat_index + 1][min_lon_index] # perform bilinear interpolation on the four grid corners lat_scale = np.clip((lat - min_lat) / SAMPLING_RES, 0.0, 1.0) lon_scale = np.clip((lon - min_lon) / SAMPLING_RES, 0.0, 1.0) data_min = lon_scale * (data_se - data_sw) + data_sw data_max = lon_scale * (data_ne - data_nw) + data_nw return lat_scale * (data_max - data_min) + data_min def get_mag_declination(latitude: float, longitude: float): return get_table_data(latitude, longitude, DECLINATION_TABLE) def get_mag_inclination(latitude: float, longitude: float): return get_table_data(latitude, longitude, INCLINATION_TABLE) def get_mag_strength(latitude: float, longitude: float): return get_table_data(latitude, longitude, STRENGTH_TABLE) def reprojection(position: np.ndarray, origin_lat=-999, origin_long=-999): """ Compute the latitude and longitude coordinates from a local position """ # reproject local position to gps coordinates x_rad: float = position[1] / EARTH_RADIUS # north y_rad: float = position[0] / EARTH_RADIUS # east c: float = np.sqrt(x_rad * x_rad + y_rad * y_rad) sin_c: float = np.sin(c) cos_c: float = np.cos(c) if c != 0.0: latitude_rad = np.arcsin(cos_c * np.sin(origin_lat) + (x_rad * sin_c * np.cos(origin_lat)) / c) longitude_rad = origin_long + np.arctan2(y_rad * sin_c, c * np.cos(origin_lat) * cos_c - x_rad * np.sin(origin_lat) * sin_c) else: latitude_rad = origin_lat longitude_rad = origin_long return latitude_rad, longitude_rad	8,992	Python	58.953333	156	0.590747
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/sensor.py	""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of the Sensor class which is used as the base for all the sensors. """ __all__ = ["Sensor"] from pegasus.simulator.logic.state import State class Sensor: """The base class for implementing a sensor Attributes: update_period (float): The period for each sensor update: update_period = 1 / update_rate (in s). origin_lat (float): The latitude of the origin of the world in degrees (might get used by some sensors). origin_lon (float): The longitude of the origin of the world in degrees (might get used by some sensors). origin_alt (float): The altitude of the origin of the world relative to sea water level (might get used by some sensors) """ def __init__(self, sensor_type: str, update_rate: float): """Initialize the Sensor class Args: sensor_type (str): A name that describes the type of sensor update_rate (float): The rate at which the data in the sensor should be refreshed (in Hz) """ # Set the sensor type and update rate self._sensor_type = sensor_type self._update_rate = update_rate self._update_period = 1.0 / self._update_rate # Auxiliar variables used to control whether to update the sensor or not given the time elapsed self._first_update = True self._total_time = 0.0 # Set the "configuration of the world" - some sensors might need it self._origin_lat = -999 self._origin_lon = -999 self._origin_alt = 0.0 def initialize(self, origin_lat, origin_lon, origin_alt): """Method that initializes the sensor latitude, longitude and altitude attributes. Note: Given that some sensors require the knowledge of the latitude, longitude and altitude of the [0, 0, 0] coordinate of the world, then we might as well just save this information for whatever sensor that comes Args: origin_lat (float): The latitude of the origin of the world in degrees (might get used by some sensors). origin_lon (float): The longitude of the origin of the world in degrees (might get used by some sensors). origin_alt (float): The altitude of the origin of the world relative to sea water level (might get used by some sensors). """ self._origin_lat = origin_lat self._origin_lon = origin_lon self._origin_alt = origin_alt def set_update_rate(self, update_rate: float): """Method that changes the update rate and period of the sensor Args: update_rate (float): The new rate at which the data in the sensor should be refreshed (in Hz) """ self._update_rate = update_rate self._update_period = 1.0 / self._update_rate def update_at_rate(fnc): """Decorator function used to check if the time elapsed between the last sensor update call and the current sensor update call is higher than the defined update_rate of the sensor. If so, we need to actually compute new values to simulate a measurement of the sensor at a given rate. Args: fnc (function): The function that we want to enforce a specific update rate. Examples: >>> class GPS(Sensor): >>> @Sensor.update_at_rate >>> def update(self): >>> (do some logic here) Returns: [None, Dict]: This decorator function returns None if there was no data to be produced by the sensor at the specified timestamp or a dict with the current state of the sensor otherwise. """ # # Define a wrapper function so that the "self" of the object can be passed to the function as well def wrapper(self, state: State, dt: float): # Add the total time passed between the last time the sensor was updated and the current call self._total_time += dt # If it is time to update the sensor data, then just call the update function of the sensor if self._total_time >= self._update_period or self._first_update: # Result of the update function for the sensor result = fnc(self, state, self._total_time) # Reset the auxiliar counter variables self._first_update = False self._total_time = 0.0 return result return None return wrapper @property def sensor_type(self): """ (str) A name that describes the type of sensor. """ return self._sensor_type @property def update_rate(self): """ (float) The rate at which the data in the sensor should be refreshed (in Hz). """ return self._update_rate @property def state(self): """ (dict) A dictionary which contains the data produced by the sensor at any given time. """ return None def update(self, state: State, dt: float): """Method that should be implemented by the class that inherits Sensor. This is where the actual implementation of the sensor should be performed. Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: (dict) A dictionary containing the current state of the sensor (the data produced by the sensor) """ pass def config_from_dict(self, config_dict): """Method that should be implemented by the class that inherits Sensor. This is where the configuration of the sensor based on a dictionary input should be performed. Args: config_dict (dict): A dictionary containing the configurations of the sensor """ pass	6,081	Python	39.818792	133	0.627693
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/barometer.py	""" | File: barometer.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Simulates a barometer. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Elia Tarasov. | References: Both the original implementation provided in the gazebo based simulation and this one are based on the following article - 'A brief summary of atmospheric modeling', Cavcar, M., http://fisicaatmo.at.fcen.uba.ar/practicas/ISAweb.pdf """ __all__ = ["Barometer"] import numpy as np from pegasus.simulator.logic.state import State from pegasus.simulator.logic.sensors import Sensor from pegasus.simulator.logic.sensors.geo_mag_utils import GRAVITY_VECTOR DEFAULT_HOME_ALT_AMSL = 488.0 class Barometer(Sensor): """The class that implements a barometer sensor. This class inherits the base class Sensor. """ def __init__(self, config={}): """Initialize the Barometer class Args: config (dict): A Dictionary that contains all the parameters for configuring the Barometer - it can be empty or only have some of the parameters used by the Barometer. Examples: The dictionary default parameters are >>> {"temperature_msl": 288.15, # temperature at MSL [K] (15 [C]) >>> "pressure_msl": 101325.0, # pressure at MSL [Pa] >>> "lapse_rate": 0.0065, # reduction in temperature with altitude for troposphere [K/m] >>> "air_density_msl": 1.225, # air density at MSL [kg/m^3] >>> "absolute_zero": -273.15, # [C] >>> "drift_pa_per_sec": 0.0, # Pa >>> "update_rate": 250.0} # Hz """ # Initialize the Super class "object" attributes super().__init__(sensor_type="Barometer", update_rate=config.get("update_rate", 250.0)) self._z_start: float = None # Setup the default home altitude (aka the altitude at the [0.0, 0.0, 0.0] coordinate on the simulated world) # If desired, the user can override this default by calling the initialize() method defined inside the Sensor # implementation self._origin_alt = DEFAULT_HOME_ALT_AMSL # Define the constants for the barometer # International standard atmosphere (troposphere model - valid up to 11km) see [1] self._TEMPERATURE_MSL: float = config.get("temperature_msl", 288.15) # temperature at MSL [K] (15 [C]) self._PRESSURE_MSL: float = config.get("pressure_msl", 101325.0) # pressure at MSL [Pa] self._LAPSE_RATE: float = config.get( "lapse_rate", 0.0065 ) # reduction in temperature with altitude for troposphere [K/m] self._AIR_DENSITY_MSL: float = config.get("air_density_msl", 1.225) # air density at MSL [kg/m^3] self._ABSOLUTE_ZERO_C: float = config.get("absolute_zero", -273.15) # [C] # Set the drift for the sensor self._baro_drift_pa_per_sec: float = config.get("drift_pa_per_sec", 0.0) # Auxiliar variables for generating the noise self._baro_rnd_use_last: bool = False self._baro_rnd_y2: float = 0.0 self._baro_drift_pa: float = 0.0 # Save the current state measured by the Baramoter self._state = {"absolute_pressure": 0.0, "pressure_altitude": 0.0, "temperature": 0.0} @property def state(self): """ (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time """ return self._state @Sensor.update_at_rate def update(self, state: State, dt: float): """Method that implements the logic of a barometer. In this method we compute the relative altitude of the vehicle relative to the origin's altitude. Aditionally, we compute the actual altitude of the vehicle, local temperature and absolute presure, based on the reference - [A brief summary of atmospheric modeling, Cavcar, M., http://fisicaatmo.at.fcen.uba.ar/practicas/ISAweb.pdf] Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: (dict) A dictionary containing the current state of the sensor (the data produced by the sensor) """ # Set the initial altitude if not yet defined if self._z_start is None: self._z_start = state.position[2] # Compute the temperature at the current altitude alt_rel: float = state.position[2] - self._z_start alt_amsl: float = self._origin_alt + alt_rel temperature_local: float = self._TEMPERATURE_MSL - self._LAPSE_RATE * alt_amsl # Compute the absolute pressure at local temperature pressure_ratio: float = np.power(self._TEMPERATURE_MSL / temperature_local, 5.2561) absolute_pressure: float = self._PRESSURE_MSL / pressure_ratio # Generate a Gaussian noise sequence using polar form of Box-Muller transformation # Honestly, this is overkill and will get replaced by numpys random.randn. if not self._baro_rnd_use_last: w: float = 1.0 while w >= 1.0: x1: float = 2.0 * np.random.randn() - 1.0 x2: float = 2.0 * np.random.randn() - 1.0 w = (x1 * x1) + (x2 * x2) w = np.sqrt((-2.0 * np.log(w)) / w) y1: float = x1 * w self._baro_rnd_y2 = x2 * w self._baro_rnd_use_last = True else: y1: float = self._baro_rnd_y2 self._baro_rnd_use_last = False # Apply noise and drift abs_pressure_noise: float = y1 # 1 Pa RMS noise self._baro_drift_pa = self._baro_drift_pa + (self._baro_drift_pa_per_sec * dt) # Update the drift absolute_pressure_noisy: float = absolute_pressure + abs_pressure_noise + self._baro_drift_pa_per_sec # Convert to hPa (Note: 1 hPa = 100 Pa) absolute_pressure_noisy_hpa: float = absolute_pressure_noisy * 0.01 # Compute air density at local temperature density_ratio: float = np.power(self._TEMPERATURE_MSL / temperature_local, 4.256) air_density: float = self._AIR_DENSITY_MSL / density_ratio # Compute pressure altitude including effect of pressure noise pressure_altitude: float = alt_amsl - (abs_pressure_noise + self._baro_drift_pa) / (np.linalg.norm(GRAVITY_VECTOR) * air_density) #pressure_altitude: float = alt_amsl - (abs_pressure_noise) / (np.linalg.norm(GRAVITY_VECTOR) * air_density) # Compute temperature in celsius temperature_celsius: float = temperature_local + self._ABSOLUTE_ZERO_C # Add the values to the dictionary and return it self._state = { "absolute_pressure": absolute_pressure_noisy_hpa, "pressure_altitude": pressure_altitude, "temperature": temperature_celsius, } return self._state	7,189	Python	46.615894	245	0.626095
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/gps.py	""" | File: gps.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Simulates a gps. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) by Amy Wagoner and Nuno Marques """ __all__ = ["GPS"] import numpy as np from pegasus.simulator.logic.sensors import Sensor from pegasus.simulator.logic.sensors.geo_mag_utils import reprojection # TODO - Introduce delay on the GPS data class GPS(Sensor): """The class that implements a GPS sensor. This class inherits the base class Sensor. """ def __init__(self, config={}): """Initialize the GPS class. Args: config (dict): A Dictionary that contains all the parameters for configuring the GPS - it can be empty or only have some of the parameters used by the GPS. Examples: The dictionary default parameters are >>> {"fix_type": 3, >>> "eph": 1.0, >>> "epv": 1.0, >>> "sattelites_visible": 10, >>> "gps_xy_random_walk": 2.0, # (m/s) / sqrt(hz) >>> "gps_z_random_walk": 4.0, # (m/s) / sqrt(hz) >>> "gps_xy_noise_density": 2.0e-4, # (m) / sqrt(hz) >>> "gps_z_noise_density": 4.0e-4, # (m) / sqrt(hz) >>> "gps_vxy_noise_density": 0.2, # (m/s) / sqrt(hz) >>> "gps_vz_noise_density": 0.4, # (m/s) / sqrt(hz) >>> "gps_correlation_time": 60, # s >>> "update_rate": 1.0 # Hz >>> } """ # Initialize the Super class "object" attributes super().__init__(sensor_type="GPS", update_rate=config.get("update_rate", 250.0)) # Define the GPS simulated/fixed values self._fix_type = config.get("fix_type", 3) self._eph = config.get("eph", 1.0) self._epv = config.get("epv", 1.0) self._sattelites_visible = config.get("sattelites_visible", 10) # Parameters for GPS random walk self._random_walk_gps = np.array([0.0, 0.0, 0.0]) self._gps_xy_random_walk = config.get("gps_xy_random_walk", 2.0) # (m/s) / sqrt(hz) self._gps_z_random_walk = config.get("gps_z_random_walk", 4.0) # (m/s) / sqrt(hz) # Parameters for the position noise self._noise_gps_pos = np.array([0.0, 0.0, 0.0]) self._gps_xy_noise_density = config.get("gps_xy_noise_density", 2.0e-4) # (m) / sqrt(hz) self._gps_z_noise_density = config.get("gps_z_noise_density", 4.0e-4) # (m) / sqrt(hz) # Parameters for the velocity noise self._noise_gps_vel = np.array([0.0, 0.0, 0.0]) self._gps_vxy_noise_density = config.get("gps_vxy_noise_density", 0.2) # (m/s) / sqrt(hz) self._gps_vz_noise_density = config.get("gps_vz_noise_density", 0.4) # (m/s) / sqrt(hz) # Parameters for the GPS bias self._gps_bias = np.array([0.0, 0.0, 0.0]) self._gps_correlation_time = config.get("gps_correlation_time", 60) # Save the current state measured by the GPS (and initialize at the origin) self._state = { "latitude": np.radians(self._origin_lat), "longitude": np.radians(self._origin_lon), "altitude": self._origin_alt, "eph": 1.0, "epv": 1.0, "speed": 0.0, "velocity_north": 0.0, "velocity_east": 0.0, "velocity_down": 0.0, # Constant values "fix_type": self._fix_type, "eph": self._eph, "epv": self._epv, "cog": 0.0, "sattelites_visible": self._sattelites_visible, "latitude_gt": np.radians(self._origin_lat), "longitude_gt": np.radians(self._origin_lon), "altitude_gt": self._origin_alt, } @property def state(self): """ (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time """ return self._state @Sensor.update_at_rate def update(self, state: np.ndarray, dt: float): """Method that implements the logic of a gps. In this method we start by generating the GPS bias terms which are then added to the real position of the vehicle, expressed in ENU inertial frame. This position affected by noise is reprojected in order to obtain the corresponding latitude and longitude. Additionally, to the linear velocity, noise is added. Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: (dict) A dictionary containing the current state of the sensor (the data produced by the sensor) """ # Update noise parameters self._random_walk_gps[0] = self._gps_xy_random_walk * np.sqrt(dt) * np.random.randn() self._random_walk_gps[1] = self._gps_xy_random_walk * np.sqrt(dt) * np.random.randn() self._random_walk_gps[2] = self._gps_z_random_walk * np.sqrt(dt) * np.random.randn() self._noise_gps_pos[0] = self._gps_xy_noise_density * np.sqrt(dt) * np.random.randn() self._noise_gps_pos[1] = self._gps_xy_noise_density * np.sqrt(dt) * np.random.randn() self._noise_gps_pos[2] = self._gps_z_noise_density * np.sqrt(dt) * np.random.randn() self._noise_gps_vel[0] = self._gps_vxy_noise_density * np.sqrt(dt) * np.random.randn() self._noise_gps_vel[1] = self._gps_vxy_noise_density * np.sqrt(dt) * np.random.randn() self._noise_gps_vel[2] = self._gps_vz_noise_density * np.sqrt(dt) * np.random.randn() # Perform GPS bias integration (using euler integration -> to be improved) self._gps_bias[0] = ( self._gps_bias[0] + self._random_walk_gps[0] * dt - self._gps_bias[0] / self._gps_correlation_time ) self._gps_bias[1] = ( self._gps_bias[1] + self._random_walk_gps[1] * dt - self._gps_bias[1] / self._gps_correlation_time ) self._gps_bias[2] = ( self._gps_bias[2] + self._random_walk_gps[2] * dt - self._gps_bias[2] / self._gps_correlation_time ) # reproject position with noise into geographic coordinates pos_with_noise: np.ndarray = state.position + self._noise_gps_pos + self._gps_bias latitude, longitude = reprojection(pos_with_noise, np.radians(self._origin_lat), np.radians(self._origin_lon)) # Compute the values of the latitude and longitude without noise (for groundtruth measurements) latitude_gt, longitude_gt = reprojection( state.position, np.radians(self._origin_lat), np.radians(self._origin_lon) ) # Add noise to the velocity expressed in the world frame velocity: np.ndarray = state.linear_velocity # + self._noise_gps_vel # Compute the xy speed speed: float = np.linalg.norm(velocity[:2]) # Course over ground (NOT heading, but direction of movement), # 0.0..359.99 degrees. If unknown, set to: 65535 [cdeg] (type:uint16_t) ve = velocity[0] vn = velocity[1] cog = np.degrees(np.arctan2(ve, vn)) if cog < 0.0: cog = cog + 360.0 cog = cog * 100 # Add the values to the dictionary and return it self._state = { "latitude": np.degrees(latitude), "longitude": np.degrees(longitude), "altitude": state.position[2] + self._origin_alt - self._noise_gps_pos[2] + self._gps_bias[2], "eph": 1.0, "epv": 1.0, "speed": speed, # Conversion from ENU (standard of Isaac Sim to NED - used in GPS sensors) "velocity_north": velocity[1], "velocity_east": velocity[0], "velocity_down": -velocity[2], # Constant values "fix_type": self._fix_type, "eph": self._eph, "epv": self._epv, "cog": 0.0, # cog, "sattelites_visible": self._sattelites_visible, "latitude_gt": latitude_gt, "longitude_gt": longitude_gt, "altitude_gt": state.position[2] + self._origin_alt, } return self._state	8,406	Python	43.481481	167	0.571259
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/sensors/imu.py	""" | File: imu.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Simulates an imu. Based on the implementation provided in PX4 stil_gazebo (https://github.com/PX4/PX4-SITL_gazebo) """ __all__ = ["IMU"] import numpy as np from scipy.spatial.transform import Rotation from pegasus.simulator.logic.state import State from pegasus.simulator.logic.sensors import Sensor from pegasus.simulator.logic.rotations import rot_FLU_to_FRD, rot_ENU_to_NED from pegasus.simulator.logic.sensors.geo_mag_utils import GRAVITY_VECTOR class IMU(Sensor): """The class that implements the IMU sensor. This class inherits the base class Sensor. """ def __init__(self, config={}): """Initialize the IMU class Args: config (dict): A Dictionary that contains all teh parameters for configuring the IMU - it can be empty or only have some of the parameters used by the IMU. Examples: The dictionary default parameters are >>> {"gyroscope": { >>> "noise_density": 2.0 * 35.0 / 3600.0 / 180.0 * pi, >>> "random_walk": 2.0 * 4.0 / 3600.0 / 180.0 * pi, >>> "bias_correlation_time": 1.0e3, >>> "turn_on_bias_sigma": 0.5 / 180.0 * pi}, >>> "accelerometer": { >>> "noise_density": 2.0 * 2.0e-3, >>> "random_walk": 2.0 * 3.0e-3, >>> "bias_correlation_time": 300.0, >>> "turn_on_bias_sigma": 20.0e-3 * 9.8 >>> }, >>> "update_rate": 1.0} # Hz """ # Initialize the Super class "object" attributes super().__init__(sensor_type="IMU", update_rate=config.get("update_rate", 250.0)) # Orientation noise constant self._orientation_noise: float = 0.0 # Gyroscope noise constants self._gyroscope_bias: np.ndarray = np.zeros((3,)) gyroscope_config = config.get("gyroscope", {}) self._gyroscope_noise_density = gyroscope_config.get("noise_density", 0.0003393695767766752) self._gyroscope_random_walk = gyroscope_config.get("random_walk", 3.878509448876288E-05) self._gyroscope_bias_correlation_time = gyroscope_config.get("bias_correlation_time", 1.0E3) self._gyroscope_turn_on_bias_sigma = gyroscope_config.get("turn_on_bias_sigma", 0.008726646259971648) # Accelerometer noise constants self._accelerometer_bias: np.ndarray = np.zeros((3,)) accelerometer_config = config.get("accelerometer", {}) self._accelerometer_noise_density = accelerometer_config.get("noise_density", 0.004) self._accelerometer_random_walk = accelerometer_config.get("random_walk", 0.006) self._accelerometer_bias_correlation_time = accelerometer_config.get("bias_correlation_time", 300.0) self._accelerometer_turn_on_bias_sigma = accelerometer_config.get("turn_on_bias_sigma", 0.196) # Auxiliar variable used to compute the linear acceleration of the vehicle self._prev_linear_velocity = np.zeros((3,)) # Save the current state measured by the IMU self._state = { "orientation": np.array([1.0, 0.0, 0.0, 0.0]), "angular_velocity": np.array([0.0, 0.0, 0.0]), "linear_acceleration": np.array([0.0, 0.0, 0.0]), } @property def state(self): """ (dict) The 'state' of the sensor, i.e. the data produced by the sensor at any given point in time """ return self._state @Sensor.update_at_rate def update(self, state: State, dt: float): """Method that implements the logic of an IMU. In this method we start by generating the random walk of the gyroscope. This value is then added to the real angular velocity of the vehicle (FLU relative to ENU inertial frame expressed in FLU body frame). The same logic is followed for the accelerometer and the accelerations. After this step, the angular velocity is rotated such that it expressed a FRD body frame, relative to a NED inertial frame, expressed in the FRD body frame. Additionally, the acceleration is also rotated, such that it becomes expressed in the body FRD frame of the vehicle. This sensor outputs data that follows the PX4 adopted standard. Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: (dict) A dictionary containing the current state of the sensor (the data produced by the sensor) """ # Gyroscopic terms tau_g: float = self._accelerometer_bias_correlation_time # Discrete-time standard deviation equivalent to an "integrating" sampler with integration time dt sigma_g_d: float = 1 / np.sqrt(dt) * self._gyroscope_noise_density sigma_b_g: float = self._gyroscope_random_walk # Compute exact covariance of the process after dt [Maybeck 4-114] sigma_b_g_d: float = np.sqrt(-sigma_b_g * sigma_b_g * tau_g / 2.0 * (np.exp(-2.0 * dt / tau_g) - 1.0)) # Compute state-transition phi_g_d: float = np.exp(-1.0 / tau_g * dt) # Simulate gyroscope noise processes and add them to the true angular rate. angular_velocity: np.ndarray = np.zeros((3,)) for i in range(3): self._gyroscope_bias[i] = phi_g_d * self._gyroscope_bias[i] + sigma_b_g_d * np.random.randn() angular_velocity[i] = state.angular_velocity[i] + sigma_g_d * np.random.randn() + self._gyroscope_bias[i] # Accelerometer terms tau_a: float = self._accelerometer_bias_correlation_time # Discrete-time standard deviation equivalent to an "integrating" sampler with integration time dt sigma_a_d: float = 1.0 / np.sqrt(dt) * self._accelerometer_noise_density sigma_b_a: float = self._accelerometer_random_walk # Compute exact covariance of the process after dt [Maybeck 4-114]. sigma_b_a_d: float = np.sqrt(-sigma_b_a * sigma_b_a * tau_a / 2.0 * (np.exp(-2.0 * dt / tau_a) - 1.0)) # Compute state-transition. phi_a_d: float = np.exp(-1.0 / tau_a * dt) # Compute the linear acceleration from diferentiating the velocity of the vehicle expressed in the inertial frame linear_acceleration_inertial = (state.linear_velocity - self._prev_linear_velocity) / dt linear_acceleration_inertial = linear_acceleration_inertial - GRAVITY_VECTOR # Update the previous linear velocity for the next computation self._prev_linear_velocity = state.linear_velocity # Compute the linear acceleration of the body frame, with respect to the inertial frame, expressed in the body frame linear_acceleration = np.array(Rotation.from_quat(state.attitude).inv().apply(linear_acceleration_inertial)) # Simulate the accelerometer noise processes and add them to the true linear aceleration values for i in range(3): self._accelerometer_bias[i] = phi_a_d * self._accelerometer_bias[i] + sigma_b_a_d * np.random.rand() linear_acceleration[i] = ( linear_acceleration[i] + sigma_a_d * np.random.randn() ) #+ self._accelerometer_bias[i] # TODO - Add small "noisy" to the attitude # -------------------------------------------------------------------------------------------- # Apply rotations such that we express the IMU data according to the FRD body frame convention # -------------------------------------------------------------------------------------------- # Convert the orientation to the FRD-NED standard attitude_flu_enu = Rotation.from_quat(state.attitude) attitude_frd_enu = attitude_flu_enu * rot_FLU_to_FRD attitude_frd_ned = rot_ENU_to_NED * attitude_frd_enu # Convert the angular velocity from FLU to FRD standard angular_velocity_frd = rot_FLU_to_FRD.apply(angular_velocity) # Convert the linear acceleration in the body frame from FLU to FRD standard linear_acceleration_frd = rot_FLU_to_FRD.apply(linear_acceleration) # Add the values to the dictionary and return it self._state = { "orientation": attitude_frd_ned.as_quat(), "angular_velocity": angular_velocity_frd, "linear_acceleration": linear_acceleration_frd, } return self._state	8,652	Python	48.445714	167	0.624942
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/interface/pegasus_interface.py	""" | File: pegasus_interface.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of the PegasusInterface class (a singleton) that is used to manage the Pegasus framework. """ __all__ = ["PegasusInterface"] # Importing Lock in ordef to have a multithread safe Pegasus singleton that manages the entire Pegasus extension import gc import yaml import asyncio import os from threading import Lock # NVidia API imports import carb import omni.kit.app from omni.isaac.core.world import World from omni.isaac.core.utils.stage import clear_stage, create_new_stage_async, update_stage_async from omni.isaac.core.utils.viewports import set_camera_view import omni.isaac.core.utils.nucleus as nucleus # Pegasus Simulator internal API from pegasus.simulator.params import DEFAULT_WORLD_SETTINGS, SIMULATION_ENVIRONMENTS, CONFIG_FILE from pegasus.simulator.logic.vehicle_manager import VehicleManager class PegasusInterface: """ PegasusInterface is a singleton class (there is only one object instance at any given time) that will be used to """ # The object instance of the Vehicle Manager _instance = None _is_initialized = False # Lock for safe multi-threading _lock: Lock = Lock() def __init__(self): """ Initialize the PegasusInterface singleton object (only runs once at a time) """ # If we already have an instance of the PegasusInterface, do not overwrite it! if PegasusInterface._is_initialized: return carb.log_info("Initializing the Pegasus Simulator Extension") PegasusInterface._is_initialized = True # Get a handle to the vehicle manager instance which will manage which vehicles are spawned in the world # to be controlled and simulated self._vehicle_manager = VehicleManager() # Initialize the world with the default simulation settings self._world_settings = DEFAULT_WORLD_SETTINGS self._world = None #self.initialize_world() # Initialize the latitude, longitude and altitude of the simulated environment at the (0.0, 0.0, 0.0) coordinate # from the extension configuration file self._latitude, self._longitude, self._altitude = self._get_global_coordinates_from_config() # Get the px4_path from the extension configuration file self._px4_path: str = self._get_px4_path_from_config() self._px4_default_airframe: str = self._get_px4_default_airframe_from_config() carb.log_info("Default PX4 path:" + str(self._px4_path)) @property def world(self): """The current omni.isaac.core.world World instance Returns: omni.isaac.core.world: The world instance """ return self._world @property def vehicle_manager(self): """The instance of the VehicleManager. Returns: VehicleManager: The current instance of the VehicleManager. """ return self._vehicle_manager @property def latitude(self): """The latitude of the origin of the simulated world in degrees. Returns: float: The latitude of the origin of the simulated world in degrees. """ return self._latitude @property def longitude(self): """The longitude of the origin of the simulated world in degrees. Returns: float: The longitude of the origin of the simulated world in degrees. """ return self._longitude @property def altitude(self): """The altitude of the origin of the simulated world in meters. Returns: float: The latitude of the origin of the simulated world in meters. """ return self._altitude @property def px4_path(self): """A string with the installation directory for PX4 (if it was setup). Otherwise it is None. Returns: str: A string with the installation directory for PX4 (if it was setup). Otherwise it is None. """ return self._px4_path @property def px4_default_airframe(self): """A string with the PX4 default airframe (if it was setup). Otherwise it is None. Returns: str: A string with the PX4 default airframe (if it was setup). Otherwise it is None. """ return self._px4_default_airframe def set_global_coordinates(self, latitude=None, longitude=None, altitude=None): """Method that can be used to set the latitude, longitude and altitude of the simulation world at the origin. Args: latitude (float): The latitude of the origin of the simulated world in degrees. Defaults to None. longitude (float): The longitude of the origin of the simulated world in degrees. Defaults to None. altitude (float): The altitude of the origin of the simulated world in meters. Defaults to None. """ if latitude is not None: self._latitude = latitude if longitude is not None: self._longitude = longitude if self.altitude is not None: self._altitude = altitude carb.log_warn("New global coordinates set to: " + str(self._latitude) + ", " + str(self._longitude) + ", " + str(self._altitude)) def initialize_world(self): """Method that initializes the world object """ self._world = World(**self._world_settings) #asyncio.ensure_future(self._world.initialize_simulation_context_async()) def get_vehicle(self, stage_prefix: str): """Method that returns the vehicle object given its 'stage_prefix', i.e., the name the vehicle was spawned with in the simulator. Args: stage_prefix (str): The name the vehicle will present in the simulator when spawned. Returns: Vehicle: Returns a vehicle object that was spawned with the given 'stage_prefix' """ return self._vehicle_manager.vehicles[stage_prefix] def get_all_vehicles(self): """ Method that returns a list of vehicles that are considered active in the simulator Returns: list: A list of all vehicles that are currently instantiated. """ return self._vehicle_manager.vehicles def get_default_environments(self): """ Method that returns a dictionary containing all the default simulation environments and their path """ return SIMULATION_ENVIRONMENTS def generate_quadrotor_config_from_yaml(self, file: str): """_summary_ Args: file (str): _description_ Returns: _type_: _description_ """ # Load the quadrotor configuration data from the given yaml file with open(file) as f: data = yaml.safe_load(f) return self.generate_quadrotor_config_from_dict(data) def clear_scene(self): """ Method that when invoked will clear all vehicles and the simulation environment, leaving only an empty world with a physics environment. """ # If the physics simulation was running, stop it first if self.world is not None: self.world.stop() # Clear the world if self.world is not None: self.world.clear_all_callbacks() self.world.clear() # Clear the stage clear_stage() # Remove all the robots that were spawned self._vehicle_manager.remove_all_vehicles() # Call python's garbage collection gc.collect() # Re-initialize the physics context asyncio.ensure_future(self._world.initialize_simulation_context_async()) carb.log_info("Current scene and its vehicles has been deleted") async def load_environment_async(self, usd_path: str, force_clear: bool=False): """Method that loads a given world (specified in the usd_path) into the simulator asynchronously. Args: usd_path (str): The path where the USD file describing the world is located. force_clear (bool): Whether to perform a clear before loading the asset. Defaults to False. It should be set to True only if the method is invoked from an App (GUI mode). """ # Reset and pause the world simulation (only if force_clear is true) # This is done to maximize the support between running in GUI as extension vs App if force_clear == True: # Create a new stage and initialize (or re-initialized) the world await create_new_stage_async() self._world = World(**self._world_settings) await self._world.initialize_simulation_context_async() self._world = World.instance() await self.world.reset_async() await self.world.stop_async() # Load the USD asset that will be used for the environment try: self.load_asset(usd_path, "/World/layout") except Exception as e: carb.log_warn("Could not load the desired environment: " + str(e)) carb.log_info("A new environment has been loaded successfully") def load_environment(self, usd_path: str, force_clear: bool=False): """Method that loads a given world (specified in the usd_path) into the simulator. If invoked from a python app, this method should have force_clear=False, as the world reset and stop are performed asynchronously by this method, and when we are operating in App mode, we want everything to run in sync. Args: usd_path (str): The path where the USD file describing the world is located. force_clear (bool): Whether to perform a clear before loading the asset. Defaults to False. """ asyncio.ensure_future(self.load_environment_async(usd_path, force_clear)) def load_nvidia_environment(self, environment_asset: str = "Hospital/hospital.usd"): """ Method that is used to load NVidia internally provided USD stages into the simulaton World Args: environment_asset (str): The name of the nvidia asset inside the /Isaac/Environments folder. Default to Hospital/hospital.usd. """ # Get the nvidia assets root path nvidia_assets_path = nucleus.get_assets_root_path() # Define the environments path inside the NVidia assets environments_path = "/Isaac/Environments" # Get the complete usd path usd_path = nvidia_assets_path + environments_path + "/" + environment_asset # Try to load the asset into the world self.load_asset(usd_path, "/World/layout") def load_asset(self, usd_asset: str, stage_prefix: str): """ Method that will attempt to load an asset into the current simulation world, given the USD asset path. Args: usd_asset (str): The path where the USD file describing the world is located. stage_prefix (str): The name the vehicle will present in the simulator when spawned. """ # Try to check if there is already a prim with the same stage prefix in the stage if self._world.stage.GetPrimAtPath(stage_prefix): raise Exception("A primitive already exists at the specified path") # Create the stage primitive and load the usd into it prim = self._world.stage.DefinePrim(stage_prefix) success = prim.GetReferences().AddReference(usd_asset) if not success: raise Exception("The usd asset" + usd_asset + "is not load at stage path " + stage_prefix) def set_viewport_camera(self, camera_position, camera_target): """Sets the viewport camera to given position and makes it point to another target position. Args: camera_position (list): A list with [X, Y, Z] coordinates of the camera in ENU inertial frame. camera_target (list): A list with [X, Y, Z] coordinates of the target that the camera should point to in the ENU inertial frame. """ # Set the camera view to a fixed value set_camera_view(eye=camera_position, target=camera_target) def set_world_settings(self, physics_dt=None, stage_units_in_meters=None, rendering_dt=None): """ Set the current world settings to the pre-defined settings. TODO - finish the implementation of this method. For now these new setting will never override the default ones. """ # Set the physics engine update rate if physics_dt is not None: self._world_settings["physics_dt"] = physics_dt # Set the units of the simulator to meters if stage_units_in_meters is not None: self._world_settings["stage_units_in_meters"] = stage_units_in_meters # Set the render engine update rate (might not be the same as the physics engine) if rendering_dt is not None: self._world_settings["rendering_dt"] = rendering_dt def _get_px4_path_from_config(self): """ Method that reads the configured PX4 installation directory from the extension configuration file Returns: str: A string with the path to the px4 configuration directory or empty string '' """ px4_dir = "" # Open the configuration file. If it fails, just return the empty path try: with open(CONFIG_FILE, 'r') as f: data = yaml.safe_load(f) px4_dir = os.path.expanduser(data.get("px4_dir", None)) except: carb.log_warn("Could not retrieve px4_dir from: " + str(CONFIG_FILE)) return px4_dir def _get_px4_default_airframe_from_config(self): """ Method that reads the configured PX4 default airframe from the extension configuration file Returns: str: A string with the path to the PX4 default airframe or empty string '' """ px4_default_airframe = "" # Open the configuration file. If it fails, just return the empty path try: with open(CONFIG_FILE, 'r') as f: data = yaml.safe_load(f) px4_default_airframe = os.path.expanduser(data.get("px4_default_airframe", None)) except: carb.log_warn("Could not retrieve px4_default_airframe from: " + str(CONFIG_FILE)) return px4_default_airframe def _get_global_coordinates_from_config(self): """Method that reads the default latitude, longitude and altitude from the extension configuration file Returns: (float, float, float): A tuple of 3 floats with the latitude, longitude and altitude to use as the origin of the world """ latitude = 0.0 longitude = 0.0 altitude = 0.0 # Open the configuration file. If it fails, just return the empty path try: with open(CONFIG_FILE, 'r') as f: data = yaml.safe_load(f) # Try to read the coordinates from the configuration file global_coordinates = data.get("global_coordinates", {}) latitude = global_coordinates.get("latitude", 0.0) longitude = global_coordinates.get("longitude", 0.0) altitude = global_coordinates.get("altitude", 0.0) except: carb.log_warn("Could not retrieve the global coordinates from: " + str(CONFIG_FILE)) return (latitude, longitude, altitude) def set_px4_path(self, path: str): """Method that allows a user to save a new px4 directory in the configuration files of the extension. Args: absolute_path (str): The new path of the px4-autopilot installation directory """ # Save the new path for current use during this simulation self._px4_path = os.path.expanduser(path) # Save the new path in the configurations file for the next simulations try: # Open the configuration file and the all the configurations that it contains with open(CONFIG_FILE, 'r') as f: data = yaml.safe_load(f) # Open the configuration file. If it fails, just warn in the console with open(CONFIG_FILE, 'w') as f: data["px4_dir"] = path yaml.dump(data, f) except: carb.log_warn("Could not save px4_dir to: " + str(CONFIG_FILE)) carb.log_warn("New px4_dir set to: " + str(self._px4_path)) def set_px4_default_airframe(self, airframe: str): """Method that allows a user to save a new px4 default airframe for the extension. Args: absolute_path (str): The new px4 default airframe """ # Save the new path for current use during this simulation self._px4_default_airframe = airframe # Save the new path in the configurations file for the next simulations try: # Open the configuration file and the all the configurations that it contains with open(CONFIG_FILE, 'r') as f: data = yaml.safe_load(f) # Open the configuration file. If it fails, just warn in the console with open(CONFIG_FILE, 'w') as f: data["px4_default_airframe"] = airframe yaml.dump(data, f) except: carb.log_warn("Could not save px4_default_airframe to: " + str(CONFIG_FILE)) carb.log_warn("New px4_default_airframe set to: " + str(self._px4_default_airframe)) def set_default_global_coordinates(self): """ Method that sets the latitude, longitude and altitude from the pegasus interface to the default global coordinates specified in the extension configuration file """ self._latitude, self._longitude, self._altitude = self._get_global_coordinates_from_config() def set_new_default_global_coordinates(self, latitude: float=None, longitude: float=None, altitude: float=None): # Set the current global coordinates to the new default global coordinates self.set_global_coordinates(latitude, longitude, altitude) # Update the default global coordinates in the configuration file try: # Open the configuration file and the all the configurations that it contains with open(CONFIG_FILE, 'r') as f: data = yaml.safe_load(f) # Open the configuration file. If it fails, just warn in the console with open(CONFIG_FILE, 'w') as f: if latitude is not None: data["global_coordinates"]["latitude"] = latitude if longitude is not None: data["global_coordinates"]["longitude"] = longitude if altitude is not None: data["global_coordinates"]["altitude"] = altitude # Save the updated configurations yaml.dump(data, f) except: carb.log_warn("Could not save the new global coordinates to: " + str(CONFIG_FILE)) carb.log_warn("New global coordinates set to: latitude=" + str(latitude) + ", longitude=" + str(longitude) + ", altitude=" + str(altitude)) def __new__(cls): """Allocates the memory and creates the actual PegasusInterface object is not instance exists yet. Otherwise, returns the existing instance of the PegasusInterface class. Returns: VehicleManger: the single instance of the VehicleManager class """ # Use a lock in here to make sure we do not have a race condition # when using multi-threading and creating the first instance of the Pegasus extension manager with cls._lock: if cls._instance is None: cls._instance = object.__new__(cls) return PegasusInterface._instance def __del__(self): """Destructor for the object. Destroys the only existing instance of this class.""" PegasusInterface._instance = None PegasusInterface._is_initialized = False	20,371	Python	38.557281	147	0.63502
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/backend.py	""" | File: backend.py | Author: Marcelo Jacinto ([email protected]) | Description: | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ class Backend: """ This class defines the templates for the communication and control backend. Every vehicle can have at least one backend at the same time. Every timestep, the methods 'update_state' and 'update_sensor' are called to update the data produced by the simulation, i.e. for every time step the backend will receive teh current state of the vehicle and its sensors. Additionally, the backend must provide a method named 'input_reference' which will be used by the vehicle simulation to know the desired angular velocities to apply to the rotors of the vehicle. The method 'update' is called on every physics step and can be use to implement some logic or send data to another interface (such as PX4 through mavlink or ROS2). The methods 'start', 'stop' and 'reset' are callbacks that get called when the simulation is started, stoped and reset as the name implies. """ def __init__(self): """Initialize the Backend class """ self._vehicle = None """ Properties """ @property def vehicle(self): """A reference to the vehicle associated with this backend. Returns: Vehicle: A reference to the vehicle associated with this backend. """ return self._vehicle def initialize(self, vehicle): """A method that can be invoked when the simulation is starting to give access to the control backend to the entire vehicle object. Even though we provide update_sensor and update_state callbacks that are called at every physics step with the latest vehicle state and its sensor data, having access to the full vehicle object may prove usefull under some circumstances. This is nice to give users the possibility of overiding default vehicle behaviour via this control backend structure. Args: vehicle (Vehicle): A reference to the vehicle that this sensor is associated with """ self._vehicle = vehicle def update_sensor(self, sensor_type: str, data): """Method that when implemented, should handle the receival of sensor data Args: sensor_type (str): A name that describes the type of sensor data (dict): A dictionary that contains the data produced by the sensor """ pass def update_state(self, state): """Method that when implemented, should handle the receival of the state of the vehicle using this callback Args: state (State): The current state of the vehicle. """ pass def input_reference(self): """Method that when implemented, should return a list of desired angular velocities to apply to the vehicle rotors """ return [] def update(self, dt: float): """Method that when implemented, should be used to update the state of the backend and the information being sent/received from the communication interface. 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). """ pass def start(self): """Method that when implemented should handle the begining of the simulation of vehicle """ pass def stop(self): """Method that when implemented should handle the stopping of the simulation of vehicle """ pass def reset(self): """Method that when implemented, should handle the reset of the vehicle simulation to its original state """ pass	3,830	Python	40.193548	143	0.674935
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/__init__.py	""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .backend import Backend from .mavlink_backend import MavlinkBackend, MavlinkBackendConfig from .ros2_backend import ROS2Backend	288	Python	31.111108	82	0.784722
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/ros2_backend.py	""" | File: ros2_backend.py | Author: Marcelo Jacinto ([email protected]) | Description: File that implements the ROS2 Backend for communication/control with/of the vehicle simulation through ROS2 topics | License: BSD-3-Clause. Copyright (c) 2024, Marcelo Jacinto. All rights reserved. """ import carb from omni.isaac.core.utils.extensions import disable_extension, enable_extension # Perform some checks, because Isaac Sim some times does not play nice when using ROS/ROS2 disable_extension("omni.isaac.ros_bridge") enable_extension("omni.isaac.ros2_bridge") # ROS2 imports import rclpy from std_msgs.msg import Float64 from geometry_msgs.msg import TransformStamped from sensor_msgs.msg import Imu, MagneticField, NavSatFix, NavSatStatus from geometry_msgs.msg import PoseStamped, TwistStamped, AccelStamped # TF imports from tf2_ros.static_transform_broadcaster import StaticTransformBroadcaster from tf2_ros.transform_broadcaster import TransformBroadcaster from pegasus.simulator.logic.backends.backend import Backend class ROS2Backend(Backend): def __init__(self, vehicle_id: int, num_rotors=4, config: dict = {}): """Initialize the ROS2 Camera class Args: camera_prim_path (str): Path to the camera prim. Global path when it starts with `/`, else local to vehicle prim path config (dict): A Dictionary that contains all the parameters for configuring the ROS2Camera - it can be empty or only have some of the parameters used by the ROS2Camera. Examples: The dictionary default parameters are >>> {"namespace": "drone" # Namespace to append to the topics >>> "pub_pose": True, # Publish the pose of the vehicle >>> "pub_twist": True, # Publish the twist of the vehicle >>> "pub_twist_inertial": True, # Publish the twist of the vehicle in the inertial frame >>> "pub_accel": True, # Publish the acceleration of the vehicle >>> "pub_imu": True, # Publish the IMU data >>> "pub_mag": True, # Publish the magnetometer data >>> "pub_gps": True, # Publish the GPS data >>> "pub_gps_vel": True, # Publish the GPS velocity data >>> "pose_topic": "state/pose", # Position and attitude of the vehicle in ENU >>> "twist_topic": "state/twist", # Linear and angular velocities in the body frame of the vehicle >>> "twist_inertial_topic": "state/twist_inertial" # Linear velocity of the vehicle in the inertial frame >>> "accel_topic": "state/accel", # Linear acceleration of the vehicle in the inertial frame >>> "imu_topic": "sensors/imu", # IMU data >>> "mag_topic": "sensors/mag", # Magnetometer data >>> "gps_topic": "sensors/gps", # GPS data >>> "gps_vel_topic": "sensors/gps_twist", # GPS velocity data """ # Save the configurations for this backend self._id = vehicle_id self._num_rotors = num_rotors self._namespace = config.get("namespace", "drone" + str(vehicle_id)) # Start the actual ROS2 setup here rclpy.init() self.node = rclpy.create_node("vehicle_" + str(vehicle_id)) # Create publishers for the state of the vehicle in ENU if config.get("pub_pose", True): self.pose_pub = self.node.create_publisher(PoseStamped, self._namespace + str(self._id) + "/" + config.get("pose_topic", "state/pose"), rclpy.qos.qos_profile_sensor_data) if config.get("pub_twist", True): self.twist_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + "/" + config.get("twist_topic", "state/twist"), rclpy.qos.qos_profile_sensor_data) if config.get("pub_twist_inertial", True): self.twist_inertial_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + "/" + config.get("twist_inertial_topic", "state/twist_inertial"), rclpy.qos.qos_profile_sensor_data) if config.get("pub_accel", True): self.accel_pub = self.node.create_publisher(AccelStamped, self._namespace + str(self._id) + "/" + config.get("accel_topic", "state/accel"), rclpy.qos.qos_profile_sensor_data) # Create publishers for some sensor data if config.get("pub_imu", True): self.imu_pub = self.node.create_publisher(Imu, self._namespace + str(self._id) + "/" + config.get("imu_topic", "sensors/imu"), rclpy.qos.qos_profile_sensor_data) if config.get("pub_mag", True): self.mag_pub = self.node.create_publisher(MagneticField, self._namespace + str(self._id) + "/" + config.get("mag_topic", "sensors/mag"), rclpy.qos.qos_profile_sensor_data) if config.get("pub_gps", True): self.gps_pub = self.node.create_publisher(NavSatFix, self._namespace + str(self._id) + "/" + config.get("gps_topic", "sensors/gps"), rclpy.qos.qos_profile_sensor_data) if config.get("pub_gps_vel", True): self.gps_vel_pub = self.node.create_publisher(TwistStamped, self._namespace + str(self._id) + "/" + config.get("gps_vel_topic", "sensors/gps_twist"), rclpy.qos.qos_profile_sensor_data) # Subscribe to vector of floats with the target angular velocities to control the vehicle # This is not ideal, but we need to reach out to NVIDIA so that they can improve the ROS2 support with custom messages # The current setup as it is.... its a pain!!!! self.rotor_subs = [] for i in range(self._num_rotors): self.rotor_subs.append(self.node.create_subscription(Float64, self._namespace + str(self._id) + "/control/rotor" + str(i) + "/ref", lambda x: self.rotor_callback(x, i),10)) # Setup zero input reference for the thrusters self.input_ref = [0.0 for i in range(self._num_rotors)] # Initiliaze the static tf broadcaster for the sensors self.tf_static_broadcaster = StaticTransformBroadcaster(self.node) # Initialize the static tf broadcaster for the base_link transformation self.send_static_transforms() # Initialize the dynamic tf broadcaster for the position of the body of the vehicle (base_link) with respect to the inertial frame (map - ENU) expressed in the inertil frame (map - ENU) self.tf_broadcaster = TransformBroadcaster(self.node) def send_static_transforms(self): # Create the transformation from base_link FLU (ROS standard) to base_link FRD (standard in airborn and marine vehicles) t = TransformStamped() t.header.stamp = self.node.get_clock().now().to_msg() t.header.frame_id = self._namespace + '_' + 'base_link' t.child_frame_id = self._namespace + '_' + 'base_link_frd' # Converts from FLU to FRD t.transform.translation.x = 0.0 t.transform.translation.y = 0.0 t.transform.translation.z = 0.0 t.transform.rotation.x = 1.0 t.transform.rotation.y = 0.0 t.transform.rotation.z = 0.0 t.transform.rotation.w = 0.0 self.tf_static_broadcaster.sendTransform(t) # Create the transform from map, i.e inertial frame (ROS standard) to map_ned (standard in airborn or marine vehicles) t = TransformStamped() t.header.stamp = self.node.get_clock().now().to_msg() t.header.frame_id = "map" t.child_frame_id = "map_ned" # Converts ENU to NED t.transform.translation.x = 0.0 t.transform.translation.y = 0.0 t.transform.translation.z = 0.0 t.transform.rotation.x = -0.7071068 t.transform.rotation.y = -0.7071068 t.transform.rotation.z = 0.0 t.transform.rotation.w = 0.0 self.tf_static_broadcaster.sendTransform(t) def update_state(self, state): """ Method that when implemented, should handle the receivel of the state of the vehicle using this callback """ pose = PoseStamped() twist = TwistStamped() twist_inertial = TwistStamped() accel = AccelStamped() # Update the header pose.header.stamp = self.node.get_clock().now().to_msg() twist.header.stamp = pose.header.stamp twist_inertial.header.stamp = pose.header.stamp accel.header.stamp = pose.header.stamp pose.header.frame_id = "map" twist.header.frame_id = self._namespace + "_" + "base_link" twist_inertial.header.frame_id = "map" accel.header.frame_id = "map" # Fill the position and attitude of the vehicle in ENU pose.pose.position.x = state.position[0] pose.pose.position.y = state.position[1] pose.pose.position.z = state.position[2] pose.pose.orientation.x = state.attitude[0] pose.pose.orientation.y = state.attitude[1] pose.pose.orientation.z = state.attitude[2] pose.pose.orientation.w = state.attitude[3] # Fill the linear and angular velocities in the body frame of the vehicle twist.twist.linear.x = state.linear_body_velocity[0] twist.twist.linear.y = state.linear_body_velocity[1] twist.twist.linear.z = state.linear_body_velocity[2] twist.twist.angular.x = state.angular_velocity[0] twist.twist.angular.y = state.angular_velocity[1] twist.twist.angular.z = state.angular_velocity[2] # Fill the linear velocity of the vehicle in the inertial frame twist_inertial.twist.linear.x = state.linear_velocity[0] twist_inertial.twist.linear.y = state.linear_velocity[1] twist_inertial.twist.linear.z = state.linear_velocity[2] # Fill the linear acceleration in the inertial frame accel.accel.linear.x = state.linear_acceleration[0] accel.accel.linear.y = state.linear_acceleration[1] accel.accel.linear.z = state.linear_acceleration[2] # Publish the messages containing the state of the vehicle self.pose_pub.publish(pose) self.twist_pub.publish(twist) self.twist_inertial_pub.publish(twist_inertial) self.accel_pub.publish(accel) # Update the dynamic tf broadcaster with the current position of the vehicle in the inertial frame t = TransformStamped() t.header.stamp = pose.header.stamp t.header.frame_id = "map" t.child_frame_id = self._namespace + '_' + 'base_link' t.transform.translation.x = state.position[0] t.transform.translation.y = state.position[1] t.transform.translation.z = state.position[2] t.transform.rotation.x = state.attitude[0] t.transform.rotation.y = state.attitude[1] t.transform.rotation.z = state.attitude[2] t.transform.rotation.w = state.attitude[3] self.tf_broadcaster.sendTransform(t) def rotor_callback(self, ros_msg: Float64, rotor_id): # Update the reference for the rotor of the vehicle self.input_ref[rotor_id] = float(ros_msg.data) def update_sensor(self, sensor_type: str, data): """ Method that when implemented, should handle the receival of sensor data """ if sensor_type == "IMU": self.update_imu_data(data) elif sensor_type == "GPS": self.update_gps_data(data) elif sensor_type == "Magnetometer": self.update_mag_data(data) else: pass def update_imu_data(self, data): msg = Imu() # Update the header msg.header.stamp = self.node.get_clock().now().to_msg() msg.header.frame_id = self._namespace + '_' + "base_link_frd" # Update the angular velocity (NED + FRD) msg.angular_velocity.x = data["angular_velocity"][0] msg.angular_velocity.y = data["angular_velocity"][1] msg.angular_velocity.z = data["angular_velocity"][2] # Update the linear acceleration (NED) msg.linear_acceleration.x = data["linear_acceleration"][0] msg.linear_acceleration.y = data["linear_acceleration"][1] msg.linear_acceleration.z = data["linear_acceleration"][2] # Publish the message with the current imu state self.imu_pub.publish(msg) def update_gps_data(self, data): msg = NavSatFix() msg_vel = TwistStamped() # Update the headers msg.header.stamp = self.node.get_clock().now().to_msg() msg.header.frame_id = "map_ned" msg_vel.header.stamp = msg.header.stamp msg_vel.header.frame_id = msg.header.frame_id # Update the status of the GPS status_msg = NavSatStatus() status_msg.status = 0 # unaugmented fix position status_msg.service = 1 # GPS service msg.status = status_msg # Update the latitude, longitude and altitude msg.latitude = data["latitude"] msg.longitude = data["longitude"] msg.altitude = data["altitude"] # Update the velocity of the vehicle measured by the GPS in the inertial frame (NED) msg_vel.twist.linear.x = data["velocity_north"] msg_vel.twist.linear.y = data["velocity_east"] msg_vel.twist.linear.z = data["velocity_down"] # Publish the message with the current GPS state self.gps_pub.publish(msg) self.gps_vel_pub.publish(msg_vel) def update_mag_data(self, data): msg = MagneticField() # Update the headers msg.header.stamp = self.node.get_clock().now().to_msg() msg.header.frame_id = "base_link_frd" msg.magnetic_field.x = data["magnetic_field"][0] msg.magnetic_field.y = data["magnetic_field"][1] msg.magnetic_field.z = data["magnetic_field"][2] # Publish the message with the current magnetic data self.mag_pub.publish(msg) 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 when implemented, should be used to update the state of the backend and the information being sent/received from the communication interface. This method will be called by the simulation on every physics step """ # In this case, do nothing as we are sending messages as soon as new data arrives from the sensors and state # and updating the reference for the thrusters as soon as receiving from ROS2 topics # Just poll for new ROS 2 messages in a non-blocking way rclpy.spin_once(self.node, timeout_sec=0) def start(self): """ Method that when implemented should handle the begining of the simulation of vehicle """ # Reset the reference for the thrusters self.input_ref = [0.0 for i in range(self._num_rotors)] def stop(self): """ Method that when implemented should handle the stopping of the simulation of vehicle """ # Reset the reference for the thrusters self.input_ref = [0.0 for i in range(self._num_rotors)] def reset(self): """ Method that when implemented, should handle the reset of the vehicle simulation to its original state """ # Reset the reference for the thrusters self.input_ref = [0.0 for i in range(self._num_rotors)]	15,962	Python	45.40407	213	0.626237
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/mavlink_backend.py	""" | File: mavlink_backend.py | Author: Marcelo Jacinto ([email protected]) | Description: File that implements the Mavlink Backend for communication/control with/of the vehicle simulation | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ __all__ = ["MavlinkBackend", "MavlinkBackendConfig"] import carb import time import numpy as np from pymavlink import mavutil from pegasus.simulator.logic.state import State from pegasus.simulator.logic.backends.backend import Backend from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface from pegasus.simulator.logic.backends.tools.px4_launch_tool import PX4LaunchTool class SensorSource: """ The binary codes to signal which simulated data is being sent through mavlink Atribute: | ACCEL (int): mavlink binary code for the accelerometer (0b0000000000111 = 7) | GYRO (int): mavlink binary code for the gyroscope (0b0000000111000 = 56) | MAG (int): mavlink binary code for the magnetometer (0b0000111000000=448) | BARO (int): mavlink binary code for the barometer (0b1101000000000=6656) | DIFF_PRESS (int): mavlink binary code for the pressure sensor (0b0010000000000=1024) """ ACCEL: int = 7 GYRO: int = 56 MAG: int = 448 BARO: int = 6656 DIFF_PRESS: int = 1024 class SensorMsg: """ An auxiliary data class where we write all the sensor data that is going to be sent through mavlink """ def __init__(self): # IMU Data self.new_imu_data: bool = False self.received_first_imu: bool = False self.xacc: float = 0.0 self.yacc: float = 0.0 self.zacc: float = 0.0 self.xgyro: float = 0.0 self.ygyro: float = 0.0 self.zgyro: float = 0.0 # Baro Data self.new_bar_data: bool = False self.abs_pressure: float = 0.0 self.pressure_alt: float = 0.0 self.temperature: float = 0.0 # Magnetometer Data self.new_mag_data: bool = False self.xmag: float = 0.0 self.ymag: float = 0.0 self.zmag: float = 0.0 # Airspeed Data self.new_press_data: bool = False self.diff_pressure: float = 0.0 # GPS Data self.new_gps_data: bool = False self.fix_type: int = 0 self.latitude_deg: float = -999 self.longitude_deg: float = -999 self.altitude: float = -999 self.eph: float = 1.0 self.epv: float = 1.0 self.velocity: float = 0.0 self.velocity_north: float = 0.0 self.velocity_east: float = 0.0 self.velocity_down: float = 0.0 self.cog: float = 0.0 self.satellites_visible: int = 0 # Vision Pose self.new_vision_data: bool = False self.vision_x: float = 0.0 self.vision_y: float = 0.0 self.vision_z: float = 0.0 self.vision_roll: float = 0.0 self.vision_pitch: float = 0.0 self.vision_yaw: float = 0.0 self.vision_covariance = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) # Simulation State self.new_sim_state: bool = False self.sim_attitude = [1.0, 0.0, 0.0, 0.0] # [w, x, y, z] self.sim_acceleration = [0.0, 0.0, 0.0] # [x,y,z body acceleration] self.sim_angular_vel = [0.0, 0.0, 0.0] # [roll-rate, pitch-rate, yaw-rate] rad/s self.sim_lat = 0.0 # [deg] self.sim_lon = 0.0 # [deg] self.sim_alt = 0.0 # [m] self.sim_ind_airspeed = 0.0 # Indicated air speed self.sim_true_airspeed = 0.0 # Indicated air speed self.sim_velocity_inertial = [0.0, 0.0, 0.0] # North-east-down [m/s] class ThrusterControl: """ An auxiliary data class that saves the thrusters command data received via mavlink and scales them into individual angular velocities expressed in rad/s to apply to each rotor """ def __init__( self, num_rotors: int = 4, input_offset=[0, 0, 0, 0], input_scaling=[0, 0, 0, 0], zero_position_armed=[100, 100, 100, 100], ): """Initialize the ThrusterControl object Args: num_rotors (int): The number of rotors that the actual system has 4. input_offset (list): A list with the offsets to apply to the rotor values received via mavlink. Defaults to [0, 0, 0, 0]. input_scaling (list): A list with the scaling to apply to the rotor values received via mavlink. Defaults to [0, 0, 0, 0]. zero_position_armed (list): Another list of offsets to apply to the rotor values received via mavlink. Defaults to [100, 100, 100, 100]. """ self.num_rotors: int = num_rotors # Values to scale and offset the rotor control inputs received from PX4 assert len(input_offset) == self.num_rotors self.input_offset = input_offset assert len(input_scaling) == self.num_rotors self.input_scaling = input_scaling assert len(zero_position_armed) == self.num_rotors self.zero_position_armed = zero_position_armed # The actual speed references to apply to the vehicle rotor joints self._input_reference = [0.0 for i in range(self.num_rotors)] @property def input_reference(self): """A list of floats with the angular velocities in rad/s Returns: list: A list of floats with the angular velocities to apply to each rotor, expressed in rad/s """ return self._input_reference def update_input_reference(self, controls): """Takes a list with the thrust controls received via mavlink and scales them in order to generated the equivalent angular velocities in rad/s Args: controls (list): A list of ints with thrust controls received via mavlink """ # Check if the number of controls received is correct if len(controls) < self.num_rotors: carb.log_warn("Did not receive enough inputs for all the rotors") return # Update the desired reference for every rotor (and saturate according to the min and max values) for i in range(self.num_rotors): # Compute the actual velocity reference to apply to each rotor self._input_reference[i] = (controls[i] + self.input_offset[i]) * self.input_scaling[ i ] + self.zero_position_armed[i] def zero_input_reference(self): """ When this method is called, the input_reference is updated such that every rotor is stopped """ self._input_reference = [0.0 for i in range(self.num_rotors)] class MavlinkBackendConfig: """ An auxiliary data class used to store all the configurations for the mavlink communications. """ def __init__(self, config={}): """ Initialize the MavlinkBackendConfig class Args: config (dict): A Dictionary that contains all the parameters for configuring the Mavlink interface - it can be empty or only have some of the parameters used by this backend. Examples: The dictionary default parameters are >>> {"vehicle_id": 0, >>> "connection_type": "tcpin", >>> "connection_ip": "localhost", >>> "connection_baseport": 4560, >>> "px4_autolaunch": True, >>> "px4_dir": "PegasusInterface().px4_path", >>> "px4_vehicle_model": "gazebo-classic_iris", >>> "enable_lockstep": True, >>> "num_rotors": 4, >>> "input_offset": [0.0, 0.0, 0.0, 0.0], >>> "input_scaling": [1000.0, 1000.0, 1000.0, 1000.0], >>> "zero_position_armed": [100.0, 100.0, 100.0, 100.0], >>> "update_rate": 250.0 >>> } """ # Configurations for the mavlink communication protocol (note: the vehicle id is sumed to the connection_baseport) self.vehicle_id = config.get("vehicle_id", 0) self.connection_type = config.get("connection_type", "tcpin") self.connection_ip = config.get("connection_ip", "localhost") self.connection_baseport = config.get("connection_baseport", 4560) # Configure whether to launch px4 in the background automatically or not for every vehicle launched self.px4_autolaunch: bool = config.get("px4_autolaunch", True) self.px4_dir: str = config.get("px4_dir", PegasusInterface().px4_path) self.px4_vehicle_model: str = config.get("px4_vehicle_model", "gazebo-classic_iris") # Configurations to interpret the rotors control messages coming from mavlink self.enable_lockstep: bool = config.get("enable_lockstep", True) self.num_rotors: int = config.get("num_rotors", 4) self.input_offset = config.get("input_offset", [0.0, 0.0, 0.0, 0.0]) self.input_scaling = config.get("input_scaling", [1000.0, 1000.0, 1000.0, 1000.0]) self.zero_position_armed = config.get("zero_position_armed", [100.0, 100.0, 100.0, 100.0]) # The update rate at which we will be sending data to mavlink (TODO - remove this from here in the future # and infer directly from the function calls) self.update_rate: float = config.get("update_rate", 250.0) # [Hz] class MavlinkBackend(Backend): """ The Mavlink Backend used to receive the vehicle's state and sensor data in order to send to PX4 through mavlink. It also receives via mavlink the thruster commands to apply to each vehicle rotor. """ def __init__(self, config=MavlinkBackendConfig()): """Initialize the MavlinkBackend Args: config (MavlinkBackendConfig): The configuration class for the MavlinkBackend. Defaults to MavlinkBackendConfig(). """ # Initialize the Backend object super().__init__() # Setup the desired mavlink connection port # The connection will only be created once the simulation starts self._vehicle_id = config.vehicle_id self._connection = None self._connection_port = ( config.connection_type + ":" + config.connection_ip + ":" + str(config.connection_baseport + config.vehicle_id) ) # Check if we need to autolaunch px4 in the background or not self.px4_autolaunch: bool = config.px4_autolaunch self.px4_vehicle_model: str = config.px4_vehicle_model # only needed if px4_autolaunch == True self.px4_tool: PX4LaunchTool = None self.px4_dir: str = config.px4_dir # Set the update rate used for sending the messages (TODO - remove this hardcoded value from here) self._update_rate: float = config.update_rate self._time_step: float = 1.0 / self._update_rate # s self._is_running: bool = False # Vehicle Sensor data to send through mavlink self._sensor_data: SensorMsg = SensorMsg() # Vehicle Rotor data received from mavlink self._rotor_data: ThrusterControl = ThrusterControl( config.num_rotors, config.input_offset, config.input_scaling, config.zero_position_armed ) # Vehicle actuator control data self._num_inputs: int = config.num_rotors self._input_reference: np.ndarray = np.zeros((self._num_inputs,)) self._armed: bool = False self._input_offset: np.ndarray = np.zeros((self._num_inputs,)) self._input_scaling: np.ndarray = np.zeros((self._num_inputs,)) # Select whether lockstep is enabled self._enable_lockstep: bool = config.enable_lockstep # Auxiliar variables to handle the lockstep between receiving sensor data and actuator control self._received_first_actuator: bool = False self._received_actuator: bool = False # Auxiliar variables to check if we have already received an hearbeat from the software in the loop simulation self._received_first_hearbeat: bool = False self._last_heartbeat_sent_time = 0 # Auxiliar variables for setting the u_time when sending sensor data to px4 self._current_utime: int = 0 def update_sensor(self, sensor_type: str, data): """Method that is used as callback for the vehicle for every iteration that a sensor produces new data. Only the IMU, GPS, Barometer and Magnetometer sensor data are stored to be sent through mavlink. Every other sensor data that gets passed to this function is discarded. Args: sensor_type (str): A name that describes the type of sensor data (dict): A dictionary that contains the data produced by the sensor """ if sensor_type == "IMU": self.update_imu_data(data) elif sensor_type == "GPS": self.update_gps_data(data) elif sensor_type == "Barometer": self.update_bar_data(data) elif sensor_type == "Magnetometer": self.update_mag_data(data) # If the data received is not from one of the above sensors, then this backend does # not support that sensor and it will just ignore it else: pass def update_imu_data(self, data): """Gets called by the 'update_sensor' method to update the current IMU data Args: data (dict): The data produced by an IMU sensor """ # Acelerometer data self._sensor_data.xacc = data["linear_acceleration"][0] self._sensor_data.yacc = data["linear_acceleration"][1] self._sensor_data.zacc = data["linear_acceleration"][2] # Gyro data self._sensor_data.xgyro = data["angular_velocity"][0] self._sensor_data.ygyro = data["angular_velocity"][1] self._sensor_data.zgyro = data["angular_velocity"][2] # Signal that we have new IMU data self._sensor_data.new_imu_data = True self._sensor_data.received_first_imu = True def update_gps_data(self, data): """Gets called by the 'update_sensor' method to update the current GPS data Args: data (dict): The data produced by an GPS sensor """ # GPS data self._sensor_data.fix_type = int(data["fix_type"]) self._sensor_data.latitude_deg = int(data["latitude"] * 10000000) self._sensor_data.longitude_deg = int(data["longitude"] * 10000000) self._sensor_data.altitude = int(data["altitude"] * 1000) self._sensor_data.eph = int(data["eph"]) self._sensor_data.epv = int(data["epv"]) self._sensor_data.velocity = int(data["speed"] * 100) self._sensor_data.velocity_north = int(data["velocity_north"] * 100) self._sensor_data.velocity_east = int(data["velocity_east"] * 100) self._sensor_data.velocity_down = int(data["velocity_down"] * 100) self._sensor_data.cog = int(data["cog"] * 100) self._sensor_data.satellites_visible = int(data["sattelites_visible"]) # Signal that we have new GPS data self._sensor_data.new_gps_data = True # Also update the groundtruth for the latitude and longitude self._sensor_data.sim_lat = int(data["latitude_gt"] * 10000000) self._sensor_data.sim_lon = int(data["longitude_gt"] * 10000000) self._sensor_data.sim_alt = int(data["altitude_gt"] * 1000) def update_bar_data(self, data): """Gets called by the 'update_sensor' method to update the current Barometer data Args: data (dict): The data produced by an Barometer sensor """ # Barometer data self._sensor_data.temperature = data["temperature"] self._sensor_data.abs_pressure = data["absolute_pressure"] self._sensor_data.pressure_alt = data["pressure_altitude"] # Signal that we have new Barometer data self._sensor_data.new_bar_data = True def update_mag_data(self, data): """Gets called by the 'update_sensor' method to update the current Vision data Args: data (dict): The data produced by an Vision sensor """ # Magnetometer data self._sensor_data.xmag = data["magnetic_field"][0] self._sensor_data.ymag = data["magnetic_field"][1] self._sensor_data.zmag = data["magnetic_field"][2] # Signal that we have new Magnetometer data self._sensor_data.new_mag_data = True def update_vision_data(self, data): """Method that 'in the future' will get called by the 'update_sensor' method to update the current Vision data This callback is currently not being called (TODO in a future simulator version) Args: data (dict): The data produced by an Vision sensor """ # Vision or MOCAP data self._sensor_data.vision_x = data["x"] self._sensor_data.vision_y = data["y"] self._sensor_data.vision_z = data["z"] self._sensor_data.vision_roll = data["roll"] self._sensor_data.vision_pitch = data["pitch"] self._sensor_data.vision_yaw = data["yaw"] # Signal that we have new vision or mocap data self._sensor_data.new_vision_data = True def update_state(self, state: State): """Method that is used as callback and gets called at every physics step with the current state of the vehicle. This state is then stored in order to be sent as groundtruth via mavlink Args: state (State): The current state of the vehicle. """ # Get the quaternion in the convention [x, y, z, w] attitude = state.get_attitude_ned_frd() # Rotate the quaternion to the mavlink standard self._sensor_data.sim_attitude[0] = attitude[3] self._sensor_data.sim_attitude[1] = attitude[0] self._sensor_data.sim_attitude[2] = attitude[1] self._sensor_data.sim_attitude[3] = attitude[2] # Get the angular velocity ang_vel = state.get_angular_velocity_frd() self._sensor_data.sim_angular_vel[0] = ang_vel[0] self._sensor_data.sim_angular_vel[1] = ang_vel[1] self._sensor_data.sim_angular_vel[2] = ang_vel[2] # Get the acceleration acc_vel = state.get_linear_acceleration_ned() self._sensor_data.sim_acceleration[0] = int(acc_vel[0] * 1000) self._sensor_data.sim_acceleration[1] = int(acc_vel[1] * 1000) self._sensor_data.sim_acceleration[2] = int(acc_vel[2] * 1000) # Get the latitude, longitude and altitude directly from the GPS # Get the linear velocity of the vehicle in the inertial frame lin_vel = state.get_linear_velocity_ned() self._sensor_data.sim_velocity_inertial[0] = int(lin_vel[0] * 100) self._sensor_data.sim_velocity_inertial[1] = int(lin_vel[1] * 100) self._sensor_data.sim_velocity_inertial[2] = int(lin_vel[2] * 100) # Compute the air_speed - assumed indicated airspeed due to flow aligned with pitot (body x) body_vel = state.get_linear_body_velocity_ned_frd() self._sensor_data.sim_ind_airspeed = int(body_vel[0] * 100) self._sensor_data.sim_true_airspeed = int(np.linalg.norm(lin_vel) * 100) # TODO - add wind here self._sensor_data.new_sim_state = True def input_reference(self): """Method that when implemented, should return a list of desired angular velocities to apply to the vehicle rotors """ return self._rotor_data.input_reference def __del__(self): """Gets called when the MavlinkBackend object gets destroyed. When this happens, we make sure to close any mavlink connection open for this vehicle. """ # When this object gets destroyed, close the mavlink connection to free the communication port try: self._connection.close() self._connection = None except: carb.log_info("Mavlink connection was not closed, because it was never opened") def start(self): """Method that handles the begining of the simulation of vehicle. It will try to open the mavlink connection interface and also attemp to launch px4 in a background process if that option as specified in the config class """ # If we are already running the mavlink interface, then ignore the function call if self._is_running == True: return # If the connection no longer exists (we stoped and re-started the stream, then re_intialize the interface) if self._connection is None: self.re_initialize_interface() # Set the flag to signal that the mavlink transmission has started self._is_running = True # Launch the PX4 in the background if needed if self.px4_autolaunch and self.px4_tool is None: carb.log_info("Attempting to launch PX4 in background process") self.px4_tool = PX4LaunchTool(self.px4_dir, self._vehicle_id, self.px4_vehicle_model) self.px4_tool.launch_px4() def stop(self): """Method that when called will handle the stopping of the simulation of vehicle. It will make sure that any open mavlink connection will be closed and also that the PX4 background process gets killed (if it was auto-initialized) """ # If the simulation was already stoped, then ignore the function call if self._is_running == False: return # Set the flag so that we are no longer running the mavlink interface self._is_running = False # Close the mavlink connection self._connection.close() self._connection = None # Close the PX4 if it was running if self.px4_autolaunch and self.px4_autolaunch is not None: carb.log_info("Attempting to kill PX4 background process") self.px4_tool.kill_px4() self.px4_tool = None def reset(self): """For now does nothing. Here for compatibility purposes only """ return def re_initialize_interface(self): """Auxiliar method used to get the MavlinkInterface to reset the MavlinkInterface to its initial state """ self._is_running = False # Restart the sensor data self._sensor_data = SensorMsg() # Restart the connection self._connection = mavutil.mavlink_connection(self._connection_port) # Auxiliar variables to handle the lockstep between receiving sensor data and actuator control self._received_first_actuator: bool = False self._received_actuator: bool = False # Auxiliar variables to check if we have already received an hearbeat from the software in the loop simulation self._received_first_hearbeat: bool = False self._last_heartbeat_sent_time = 0 def wait_for_first_hearbeat(self): """ Responsible for waiting for the first hearbeat. This method is locking and will only return if an hearbeat is received via mavlink. When this first heartbeat is received poll for mavlink messages """ carb.log_warn("Waiting for first hearbeat") result = self._connection.wait_heartbeat(blocking=False) if result is not None: self._received_first_hearbeat = True carb.log_warn("Received first hearbeat") def update(self, dt): """ Method that is called at every physics step to send data to px4 and receive the control inputs via mavlink Args: dt (float): The time elapsed between the previous and current function calls (s). """ # Check for the first hearbeat on the first few iterations if not self._received_first_hearbeat: self.wait_for_first_hearbeat() return # Check if we have already received IMU data. If not, start the lockstep and wait for more data if self._sensor_data.received_first_imu: while not self._sensor_data.new_imu_data and self._is_running: # Just go for the next update and then try to check if we have new simulated sensor data # DO not continue and get mavlink thrusters commands until we have simulated IMU data available return # Check if we have received any mavlink messages self.poll_mavlink_messages() # Send hearbeats at 1Hz if (time.time() - self._last_heartbeat_sent_time) > 1.0 or self._received_first_hearbeat == False: self.send_heartbeat() self._last_heartbeat_sent_time = time.time() # Update the current u_time for px4 self._current_utime += int(dt * 1000000) # Send sensor messages self.send_sensor_msgs(self._current_utime) # Send the GPS messages self.send_gps_msgs(self._current_utime) def poll_mavlink_messages(self): """ Method that is used to check if new mavlink messages were received """ # If we have not received the first hearbeat yet, do not poll for mavlink messages if self._received_first_hearbeat == False: return # Check if we need to lock and wait for actuator control data needs_to_wait_for_actuator: bool = self._received_first_actuator and self._enable_lockstep # Start by assuming that we have not received data for the actuators for the current step self._received_actuator = False # Use this loop to emulate a do-while loop (make sure this runs at least once) while True: # Try to get a message msg = self._connection.recv_match(blocking=needs_to_wait_for_actuator) # If a message was received if msg is not None: # Check if it is of the type that contains actuator controls if msg.id == mavutil.mavlink.MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS: self._received_first_actuator = True self._received_actuator = True # Handle the control of the actuation commands received by PX4 self.handle_control(msg.time_usec, msg.controls, msg.mode, msg.flags) # Check if we do not need to wait for an actuator message or we just received actuator input # If so, break out of the infinite loop if not needs_to_wait_for_actuator or self._received_actuator: break def send_heartbeat(self, mav_type=mavutil.mavlink.MAV_TYPE_GENERIC): """ Method that is used to publish an heartbear through mavlink protocol Args: mav_type (int): The ID that indicates the type of vehicle. Defaults to MAV_TYPE_GENERIC=0 """ carb.log_info("Sending heartbeat") # Note: to know more about these functions, go to pymavlink->dialects->v20->standard.py # This contains the definitions for sending the hearbeat and simulated sensor messages self._connection.mav.heartbeat_send(mav_type, mavutil.mavlink.MAV_AUTOPILOT_INVALID, 0, 0, 0) def send_sensor_msgs(self, time_usec: int): """ Method that when invoked, will send the simulated sensor data through mavlink Args: time_usec (int): The total time elapsed since the simulation started """ carb.log_info("Sending sensor msgs") # Check which sensors have new data to send fields_updated: int = 0 if self._sensor_data.new_imu_data: # Set the bit field to signal that we are sending updated accelerometer and gyro data fields_updated = fields_updated | SensorSource.ACCEL | SensorSource.GYRO self._sensor_data.new_imu_data = False if self._sensor_data.new_mag_data: # Set the bit field to signal that we are sending updated magnetometer data fields_updated = fields_updated | SensorSource.MAG self._sensor_data.new_mag_data = False if self._sensor_data.new_bar_data: # Set the bit field to signal that we are sending updated barometer data fields_updated = fields_updated | SensorSource.BARO self._sensor_data.new_bar_data = False if self._sensor_data.new_press_data: # Set the bit field to signal that we are sending updated diff pressure data fields_updated = fields_updated | SensorSource.DIFF_PRESS self._sensor_data.new_press_data = False try: self._connection.mav.hil_sensor_send( time_usec, self._sensor_data.xacc, self._sensor_data.yacc, self._sensor_data.zacc, self._sensor_data.xgyro, self._sensor_data.ygyro, self._sensor_data.zgyro, self._sensor_data.xmag, self._sensor_data.ymag, self._sensor_data.zmag, self._sensor_data.abs_pressure, self._sensor_data.diff_pressure, self._sensor_data.pressure_alt, self._sensor_data.altitude, fields_updated, ) except: carb.log_warn("Could not send sensor data through mavlink") def send_gps_msgs(self, time_usec: int): """ Method that is used to send simulated GPS data through the mavlink protocol. Args: time_usec (int): The total time elapsed since the simulation started """ carb.log_info("Sending GPS msgs") # Do not send GPS data, if no new data was received if not self._sensor_data.new_gps_data: return self._sensor_data.new_gps_data = False # Latitude, longitude and altitude (all in integers) try: self._connection.mav.hil_gps_send( time_usec, self._sensor_data.fix_type, self._sensor_data.latitude_deg, self._sensor_data.longitude_deg, self._sensor_data.altitude, self._sensor_data.eph, self._sensor_data.epv, self._sensor_data.velocity, self._sensor_data.velocity_north, self._sensor_data.velocity_east, self._sensor_data.velocity_down, self._sensor_data.cog, self._sensor_data.satellites_visible, ) except: carb.log_warn("Could not send gps data through mavlink") def send_vision_msgs(self, time_usec: int): """ Method that is used to send simulated vision/mocap data through the mavlink protocol. Args: time_usec (int): The total time elapsed since the simulation started """ carb.log_info("Sending vision/mocap msgs") # Do not send vision/mocap data, if not new data was received if not self._sensor_data.new_vision_data: return self._sensor_data.new_vision_data = False try: self._connection.mav.global_vision_position_estimate_send( time_usec, self._sensor_data.vision_x, self._sensor_data.vision_y, self._sensor_data.vision_z, self._sensor_data.vision_roll, self._sensor_data.vision_pitch, self._sensor_data.vision_yaw, self._sensor_data.vision_covariance, ) except: carb.log_warn("Could not send vision/mocap data through mavlink") def send_ground_truth(self, time_usec: int): """ Method that is used to send the groundtruth data of the vehicle through mavlink Args: time_usec (int): The total time elapsed since the simulation started """ carb.log_info("Sending groundtruth msgs") # Do not send vision/mocap data, if not new data was received if not self._sensor_data.new_sim_state or self._sensor_data.sim_alt == 0: return self._sensor_data.new_sim_state = False try: self._connection.mav.hil_state_quaternion_send( time_usec, self._sensor_data.sim_attitude, self._sensor_data.sim_angular_vel[0], self._sensor_data.sim_angular_vel[1], self._sensor_data.sim_angular_vel[2], self._sensor_data.sim_lat, self._sensor_data.sim_lon, self._sensor_data.sim_alt, self._sensor_data.sim_velocity_inertial[0], self._sensor_data.sim_velocity_inertial[1], self._sensor_data.sim_velocity_inertial[2], self._sensor_data.sim_ind_airspeed, self._sensor_data.sim_true_airspeed, self._sensor_data.sim_acceleration[0], self._sensor_data.sim_acceleration[1], self._sensor_data.sim_acceleration[2], ) except: carb.log_warn("Could not send groundtruth through mavlink") def handle_control(self, time_usec, controls, mode, flags): """ Method that when received a control message, compute the forces simulated force that should be applied on each rotor of the vehicle Args: time_usec (int): The total time elapsed since the simulation started - Ignored argument controls (list): A list of ints which contains the thrust_control received via mavlink flags: Ignored argument """ # Check if the vehicle is armed - Note: here we have to add a +1 since the code for armed is 128, but # pymavlink is return 129 (the end of the buffer) if mode == mavutil.mavlink.MAV_MODE_FLAG_SAFETY_ARMED + 1: carb.log_info("Parsing control input") # Set the rotor target speeds self._rotor_data.update_input_reference(controls) # If the vehicle is not armed, do not rotate the propellers else: self._rotor_data.zero_input_reference()	34,342	Python	39.884524	186	0.61697
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/backends/tools/px4_launch_tool.py	""" | File: px4_launch_tool.py | Author: Marcelo Jacinto ([email protected]) | Description: Defines an auxiliary tool to launch the PX4 process in the background | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ # System tools used to launch the px4 process in the brackground import os import tempfile import subprocess class PX4LaunchTool: """ A class that manages the start/stop of a px4 process. It requires only the path to the PX4 installation (assuming that PX4 was already built with 'make px4_sitl_default none'), the vehicle id and the vehicle model. """ def __init__(self, px4_dir, vehicle_id: int = 0, px4_model: str = "gazebo-classic_iris"): """Construct the PX4LaunchTool object Args: px4_dir (str): A string with the path to the PX4-Autopilot directory vehicle_id (int): The ID of the vehicle. Defaults to 0. px4_model (str): The vehicle model. Defaults to "iris". """ # Attribute that will hold the px4 process once it is running self.px4_process = None # The vehicle id (used for the mavlink port open in the system) self.vehicle_id = vehicle_id # Configurations to whether autostart px4 (SITL) automatically or have the user launch it manually on another # terminal self.px4_dir = px4_dir self.rc_script = self.px4_dir + "/ROMFS/px4fmu_common/init.d-posix/rcS" # Create a temporary filesystem for px4 to write data to/from (and modify the origin rcS files) self.root_fs = tempfile.TemporaryDirectory() # Set the environement variables that let PX4 know which vehicle model to use internally self.environment = os.environ self.environment["PX4_SIM_MODEL"] = px4_model def launch_px4(self): """ Method that will launch a px4 instance with the specified configuration """ self.px4_process = subprocess.Popen( [ self.px4_dir + "/build/px4_sitl_default/bin/px4", self.px4_dir + "/ROMFS/px4fmu_common/", "-s", self.rc_script, "-i", str(self.vehicle_id), "-d", ], cwd=self.root_fs.name, shell=False, env=self.environment, ) def kill_px4(self): """ Method that will kill a px4 instance with the specified configuration """ if self.px4_process is not None: self.px4_process.kill() self.px4_process = None def __del__(self): """ If the px4 process is still running when the PX4 launch tool object is whiped from memory, then make sure we kill the px4 instance so we don't end up with hanged px4 instances """ # Make sure the PX4 process gets killed if self.px4_process: self.kill_px4() # Make sure we clean the temporary filesystem used for the simulation self.root_fs.cleanup() # ---- Code used for debugging the px4 tool ---- def main(): px4_tool = PX4LaunchTool(os.environ["HOME"] + "/PX4-Autopilot") px4_tool.launch_px4() import time time.sleep(60) if __name__ == "__main__": main()	3,332	Python	32	122	0.612545
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/vehicle.py	""" | File: vehicle.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of the Vehicle class which is used as the base for all the vehicles. """ # Numerical computations import numpy as np from scipy.spatial.transform import Rotation # Low level APIs import carb from pxr import Usd, Gf # High level Isaac sim APIs import omni.usd from omni.isaac.core.world import World from omni.isaac.core.utils.prims import define_prim, get_prim_at_path from omni.usd import get_stage_next_free_path from omni.isaac.core.robots.robot import Robot # Extension APIs from pegasus.simulator.logic.state import State from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface from pegasus.simulator.logic.vehicle_manager import VehicleManager def get_world_transform_xform(prim: Usd.Prim): """ Get the local transformation of a prim using omni.usd.get_world_transform_matrix(). See https://docs.omniverse.nvidia.com/kit/docs/omni.usd/latest/omni.usd/omni.usd.get_world_transform_matrix.html Args: prim (Usd.Prim): The prim to calculate the world transformation. Returns: A tuple of: - Translation vector. - Rotation quaternion, i.e. 3d vector plus angle. - Scale vector. """ world_transform: Gf.Matrix4d = omni.usd.get_world_transform_matrix(prim) rotation: Gf.Rotation = world_transform.ExtractRotation() return rotation class Vehicle(Robot): def __init__( self, stage_prefix: str, usd_path: str = None, init_pos=[0.0, 0.0, 0.0], init_orientation=[0.0, 0.0, 0.0, 1.0], ): """ Class that initializes a vehicle in the isaac sim's curent stage Args: stage_prefix (str): The name the vehicle will present in the simulator when spawned. Defaults to "quadrotor". usd_path (str): The USD file that describes the looks and shape of the vehicle. Defaults to "". init_pos (list): The initial position of the vehicle in the inertial frame (in ENU convention). Defaults to [0.0, 0.0, 0.0]. init_orientation (list): The initial orientation of the vehicle in quaternion [qx, qy, qz, qw]. Defaults to [0.0, 0.0, 0.0, 1.0]. """ # Get the current world at which we want to spawn the vehicle self._world = PegasusInterface().world self._current_stage = self._world.stage # Save the name with which the vehicle will appear in the stage # and the name of the .usd file that contains its description self._stage_prefix = get_stage_next_free_path(self._current_stage, stage_prefix, False) self._usd_file = usd_path # Get the vehicle name by taking the last part of vehicle stage prefix self._vehicle_name = self._stage_prefix.rpartition("/")[-1] # Spawn the vehicle primitive in the world's stage self._prim = define_prim(self._stage_prefix, "Xform") self._prim = get_prim_at_path(self._stage_prefix) self._prim.GetReferences().AddReference(self._usd_file) # Initialize the "Robot" class # Note: we need to change the rotation to have qw first, because NVidia # does not keep a standard of quaternions inside its own libraries (not good, but okay) super().__init__( prim_path=self._stage_prefix, name=self._stage_prefix, position=init_pos, orientation=[init_orientation[3], init_orientation[0], init_orientation[1], init_orientation[2]], articulation_controller=None, ) # Add this object for the world to track, so that if we clear the world, this object is deleted from memory and # as a consequence, from the VehicleManager as well self._world.scene.add(self) # Add the current vehicle to the vehicle manager, so that it knows # that a vehicle was instantiated VehicleManager.get_vehicle_manager().add_vehicle(self._stage_prefix, self) # Variable that will hold the current state of the vehicle self._state = State() # Motor that is given as reference self._motor_speed = [] # Add a callback to the physics engine to update the current state of the system self._world.add_physics_callback(self._stage_prefix + "/state", self.update_state) # Add the update method to the physics callback if the world was received # so that we can apply forces and torques to the vehicle. Note, this method should # be implemented in classes that inherit the vehicle object self._world.add_physics_callback(self._stage_prefix + "/update", self.update) # Set the flag that signals if the simulation is running or not self._sim_running = False # Add a callback to start/stop of the simulation once the play/stop button is hit self._world.add_timeline_callback(self._stage_prefix + "/start_stop_sim", self.sim_start_stop) def __del__(self): """ Method that is invoked when a vehicle object gets destroyed. When this happens, we also invoke the 'remove_vehicle' from the VehicleManager in order to remove the vehicle from the list of active vehicles. """ # Remove this object from the vehicleHandler VehicleManager.get_vehicle_manager().remove_vehicle(self._stage_prefix) """ Properties """ @property def state(self): """The state of the vehicle. Returns: State: The current state of the vehicle, i.e., position, orientation, linear and angular velocities... """ return self._state @property def vehicle_name(self) -> str: """Vehicle name. Returns: Vehicle name (str): last prim name in vehicle prim path """ return self._vehicle_name """ Operations """ def sim_start_stop(self, event): """ Callback that is called every time there is a timeline event such as starting/stoping the simulation. Args: event: A timeline event generated from Isaac Sim, such as starting or stoping the simulation. """ # If the start/stop button was pressed, then call the start and stop methods accordingly if self._world.is_playing() and self._sim_running == False: self._sim_running = True self.start() if self._world.is_stopped() and self._sim_running == True: self._sim_running = False self.stop() def apply_force(self, force, pos=[0.0, 0.0, 0.0], body_part="/body"): """ Method that will apply a force on the rigidbody, on the part specified in the 'body_part' at its relative position given by 'pos' (following a FLU) convention. Args: force (list): A 3-dimensional vector of floats with the force [Fx, Fy, Fz] on the body axis of the vehicle according to a FLU convention. pos (list): _description_. Defaults to [0.0, 0.0, 0.0]. body_part (str): . Defaults to "/body". """ # Get the handle of the rigidbody that we will apply the force to rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + body_part) # Apply the force to the rigidbody. The force should be expressed in the rigidbody frame self._world.dc_interface.apply_body_force(rb, carb._carb.Float3(force), carb._carb.Float3(pos), False) def apply_torque(self, torque, body_part="/body"): """ Method that when invoked applies a given torque vector to /<rigid_body_name>/"body" or to /<rigid_body_name>/<body_part>. Args: torque (list): A 3-dimensional vector of floats with the force [Tx, Ty, Tz] on the body axis of the vehicle according to a FLU convention. body_part (str): . Defaults to "/body". """ # Get the handle of the rigidbody that we will apply a torque to rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + body_part) # Apply the torque to the rigidbody. The torque should be expressed in the rigidbody frame self._world.dc_interface.apply_body_torque(rb, carb._carb.Float3(torque), False) def update_state(self, dt: float): """ Method that is called at every physics step to retrieve and update the current state of the vehicle, i.e., get the current position, orientation, linear and angular velocities and acceleration of the vehicle. Args: dt (float): The time elapsed between the previous and current function calls (s). """ # Get the body frame interface of the vehicle (this will be the frame used to get the position, orientation, etc.) body = self._world.dc_interface.get_rigid_body(self._stage_prefix + "/body") # Get the current position and orientation in the inertial frame pose = self._world.dc_interface.get_rigid_body_pose(body) # Get the attitude according to the convention [w, x, y, z] prim = self._world.stage.GetPrimAtPath(self._stage_prefix + "/body") rotation_quat = get_world_transform_xform(prim).GetQuaternion() rotation_quat_real = rotation_quat.GetReal() rotation_quat_img = rotation_quat.GetImaginary() # Get the angular velocity of the vehicle expressed in the body frame of reference ang_vel = self._world.dc_interface.get_rigid_body_angular_velocity(body) # The linear velocity [x_dot, y_dot, z_dot] of the vehicle's body frame expressed in the inertial frame of reference linear_vel = self._world.dc_interface.get_rigid_body_linear_velocity(body) # Get the linear acceleration of the body relative to the inertial frame, expressed in the inertial frame # Note: we must do this approximation, since the Isaac sim does not output the acceleration of the rigid body directly linear_acceleration = (np.array(linear_vel) - self._state.linear_velocity) / dt # Update the state variable X = [x,y,z] self._state.position = np.array(pose.p) # Get the quaternion according in the [qx,qy,qz,qw] standard self._state.attitude = np.array( [rotation_quat_img[0], rotation_quat_img[1], rotation_quat_img[2], rotation_quat_real] ) # Express the velocity of the vehicle in the inertial frame X_dot = [x_dot, y_dot, z_dot] self._state.linear_velocity = np.array(linear_vel) # The linear velocity V =[u,v,w] of the vehicle's body frame expressed in the body frame of reference # Note that: x_dot = Rot * V self._state.linear_body_velocity = ( Rotation.from_quat(self._state.attitude).inv().apply(self._state.linear_velocity) ) # omega = [p,q,r] self._state.angular_velocity = Rotation.from_quat(self._state.attitude).inv().apply(np.array(ang_vel)) # The acceleration of the vehicle expressed in the inertial frame X_ddot = [x_ddot, y_ddot, z_ddot] self._state.linear_acceleration = linear_acceleration def start(self): """ Method that should be implemented by the class that inherits the vehicle object. """ pass def stop(self): """ Method that should be implemented by the class that inherits the vehicle object. """ pass def update(self, dt: float): """ Method that computes and applies the forces to the vehicle in simulation based on the motor speed. This method must be implemented by a class that inherits this type and it's called periodically by the physics engine. Args: dt (float): The time elapsed between the previous and current function calls (s). """ pass	11,970	Python	41.601423	150	0.653133
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/multirotor.py	""" | File: multirotor.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Definition of the Multirotor class which is used as the base for all the multirotor vehicles. """ import numpy as np # The vehicle interface from pegasus.simulator.logic.vehicles.vehicle import Vehicle # Mavlink interface from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend # Sensors and dynamics setup from pegasus.simulator.logic.dynamics import LinearDrag from pegasus.simulator.logic.thrusters import QuadraticThrustCurve from pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface class MultirotorConfig: """ A data class that is used for configuring a Multirotor """ def __init__(self): """ Initialization of the MultirotorConfig class """ # Stage prefix of the vehicle when spawning in the world self.stage_prefix = "quadrotor" # The USD file that describes the visual aspect of the vehicle (and some properties such as mass and moments of inertia) self.usd_file = "" # The default thrust curve for a quadrotor and dynamics relating to drag self.thrust_curve = QuadraticThrustCurve() self.drag = LinearDrag([0.50, 0.30, 0.0]) # The default sensors for a quadrotor self.sensors = [Barometer(), IMU(), Magnetometer(), GPS()] # The default graphs self.graphs = [] # The backends for actually sending commands to the vehicle. By default use mavlink (with default mavlink configurations) # [Can be None as well, if we do not desired to use PX4 with this simulated vehicle]. It can also be a ROS2 backend # or your own custom Backend implementation! self.backends = [MavlinkBackend()] class Multirotor(Vehicle): """Multirotor class - It defines a base interface for creating a multirotor """ def __init__( self, # Simulation specific configurations stage_prefix: str = "quadrotor", usd_file: str = "", vehicle_id: int = 0, # Spawning pose of the vehicle init_pos=[0.0, 0.0, 0.07], init_orientation=[0.0, 0.0, 0.0, 1.0], config=MultirotorConfig(), ): """Initializes the multirotor object Args: stage_prefix (str): The name the vehicle will present in the simulator when spawned. Defaults to "quadrotor". usd_file (str): The USD file that describes the looks and shape of the vehicle. Defaults to "". vehicle_id (int): The id to be used for the vehicle. Defaults to 0. init_pos (list): The initial position of the vehicle in the inertial frame (in ENU convention). Defaults to [0.0, 0.0, 0.07]. init_orientation (list): The initial orientation of the vehicle in quaternion [qx, qy, qz, qw]. Defaults to [0.0, 0.0, 0.0, 1.0]. config (_type_, optional): _description_. Defaults to MultirotorConfig(). """ # 1. Initiate the Vehicle object itself super().__init__(stage_prefix, usd_file, init_pos, init_orientation) # 2. Initialize all the vehicle sensors self._sensors = config.sensors for sensor in self._sensors: sensor.initialize(PegasusInterface().latitude, PegasusInterface().longitude, PegasusInterface().altitude) # Add callbacks to the physics engine to update each sensor at every timestep # and let the sensor decide depending on its internal update rate whether to generate new data self._world.add_physics_callback(self._stage_prefix + "/Sensors", self.update_sensors) # 3. Initialize all the vehicle graphs self._graphs = config.graphs for graph in self._graphs: graph.initialize(self) # 4. Setup the dynamics of the system # Get the thrust curve of the vehicle from the configuration self._thrusters = config.thrust_curve self._drag = config.drag # 5. Save the backend interface (if given in the configuration of the multirotor) # and initialize them self._backends = config.backends for backend in self._backends: backend.initialize(self) # Add a callbacks for the self._world.add_physics_callback(self._stage_prefix + "/mav_state", self.update_sim_state) def update_sensors(self, dt: float): """Callback that is called at every physics steps and will call the sensor.update method to generate new sensor data. For each data that the sensor generates, the backend.update_sensor method will also be called for every backend. For example, if new data is generated for an IMU and we have a MavlinkBackend, then the update_sensor method will be called for that backend so that this data can latter be sent thorugh mavlink. Args: dt (float): The time elapsed between the previous and current function calls (s). """ # Call the update method for the sensor to update its values internally (if applicable) for sensor in self._sensors: sensor_data = sensor.update(self._state, dt) # If some data was updated and we have a mavlink backend or ros backend (or other), then just update it if sensor_data is not None: for backend in self._backends: backend.update_sensor(sensor.sensor_type, sensor_data) def update_sim_state(self, dt: float): """ Callback that is used to "send" the current state for each backend being used to control the vehicle. This callback is called on every physics step. Args: dt (float): The time elapsed between the previous and current function calls (s). """ for backend in self._backends: backend.update_state(self._state) def start(self): """ Intializes the communication with all the backends. This method is invoked automatically when the simulation starts """ for backend in self._backends: backend.start() def stop(self): """ Signal all the backends that the simulation has stoped. This method is invoked automatically when the simulation stops """ for backend in self._backends: backend.stop() def update(self, dt: float): """ Method that computes and applies the forces to the vehicle in simulation based on the motor speed. This method must be implemented by a class that inherits this type. This callback is called on every physics step. Args: dt (float): The time elapsed between the previous and current function calls (s). """ # Get the articulation root of the vehicle articulation = self._world.dc_interface.get_articulation(self._stage_prefix) # Get the desired angular velocities for each rotor from the first backend (can be mavlink or other) expressed in rad/s if len(self._backends) != 0: desired_rotor_velocities = self._backends[0].input_reference() else: desired_rotor_velocities = [0.0 for i in range(self._thrusters._num_rotors)] # Input the desired rotor velocities in the thruster model self._thrusters.set_input_reference(desired_rotor_velocities) # Get the desired forces to apply to the vehicle forces_z, _, rolling_moment = self._thrusters.update(self._state, dt) # Apply force to each rotor for i in range(4): # Apply the force in Z on the rotor frame self.apply_force([0.0, 0.0, forces_z[i]], body_part="/rotor" + str(i)) # Generate the rotating propeller visual effect self.handle_propeller_visual(i, forces_z[i], articulation) # Apply the torque to the body frame of the vehicle that corresponds to the rolling moment self.apply_torque([0.0, 0.0, rolling_moment], "/body") # Compute the total linear drag force to apply to the vehicle's body frame drag = self._drag.update(self._state, dt) self.apply_force(drag, body_part="/body") # Call the update methods in all backends for backend in self._backends: backend.update(dt) def handle_propeller_visual(self, rotor_number, force: float, articulation): """ Auxiliar method used to set the joint velocity of each rotor (for animation purposes) based on the amount of force being applied on each joint Args: rotor_number (int): The number of the rotor to generate the rotation animation force (float): The force that is being applied on that rotor articulation (_type_): The articulation group the joints of the rotors belong to """ # Rotate the joint to yield the visual of a rotor spinning (for animation purposes only) joint = self._world.dc_interface.find_articulation_dof(articulation, "joint" + str(rotor_number)) # Spinning when armed but not applying force if 0.0 < force < 0.1: self._world.dc_interface.set_dof_velocity(joint, 5 * self._thrusters.rot_dir[rotor_number]) # Spinning when armed and applying force elif 0.1 <= force: self._world.dc_interface.set_dof_velocity(joint, 100 * self._thrusters.rot_dir[rotor_number]) # Not spinning else: self._world.dc_interface.set_dof_velocity(joint, 0) def force_and_torques_to_velocities(self, force: float, torque: np.ndarray): """ Auxiliar method used to get the target angular velocities for each rotor, given the total desired thrust [N] and torque [Nm] to be applied in the multirotor's body frame. Note: This method assumes a quadratic thrust curve. This method will be improved in a future update, and a general thrust allocation scheme will be adopted. For now, it is made to work with multirotors directly. Args: force (np.ndarray): A vector of the force to be applied in the body frame of the vehicle [N] torque (np.ndarray): A vector of the torque to be applied in the body frame of the vehicle [Nm] Returns: list: A list of angular velocities [rad/s] to apply in reach rotor to accomplish suchs forces and torques """ # Get the body frame of the vehicle rb = self._world.dc_interface.get_rigid_body(self._stage_prefix + "/body") # Get the rotors of the vehicle rotors = [self._world.dc_interface.get_rigid_body(self._stage_prefix + "/rotor" + str(i)) for i in range(self._thrusters._num_rotors)] # Get the relative position of the rotors with respect to the body frame of the vehicle (ignoring the orientation for now) relative_poses = self._world.dc_interface.get_relative_body_poses(rb, rotors) # Define the alocation matrix aloc_matrix = np.zeros((4, self._thrusters._num_rotors)) # Define the first line of the matrix (T [N]) aloc_matrix[0, :] = np.array(self._thrusters._rotor_constant) # Define the second and third lines of the matrix (\tau_x [Nm] and \tau_y [Nm]) aloc_matrix[1, :] = np.array([relative_poses[i].p[1] * self._thrusters._rotor_constant[i] for i in range(self._thrusters._num_rotors)]) aloc_matrix[2, :] = np.array([-relative_poses[i].p[0] * self._thrusters._rotor_constant[i] for i in range(self._thrusters._num_rotors)]) # Define the forth line of the matrix (\tau_z [Nm]) aloc_matrix[3, :] = np.array([self._thrusters._rolling_moment_coefficient[i] * self._thrusters._rot_dir[i] for i in range(self._thrusters._num_rotors)]) # Compute the inverse allocation matrix, so that we can get the angular velocities (squared) from the total thrust and torques aloc_inv = np.linalg.pinv(aloc_matrix) # Compute the target angular velocities (squared) squared_ang_vel = aloc_inv @ np.array([force, torque[0], torque[1], torque[2]]) # Making sure that there is no negative value on the target squared angular velocities squared_ang_vel[squared_ang_vel < 0] = 0.0 # ------------------------------------------------------------------------------------------------ # Saturate the inputs while preserving their relation to each other, by performing a normalization # ------------------------------------------------------------------------------------------------ max_thrust_vel_squared = np.power(self._thrusters.max_rotor_velocity[0], 2) max_val = np.max(squared_ang_vel) if max_val >= max_thrust_vel_squared: normalize = np.maximum(max_val / max_thrust_vel_squared, 1.0) squared_ang_vel = squared_ang_vel / normalize # Compute the angular velocities for each rotor in [rad/s] ang_vel = np.sqrt(squared_ang_vel) return ang_vel	13,252	Python	45.501754	160	0.644582
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/vehicles/multirotors/iris.py	# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig # Sensors and dynamics setup from pegasus.simulator.logic.dynamics import LinearDrag from pegasus.simulator.logic.thrusters import QuadraticThrustCurve from pegasus.simulator.logic.sensors import Barometer, IMU, Magnetometer, GPS # Mavlink interface from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend # Get the location of the IRIS asset from pegasus.simulator.params import ROBOTS class IrisConfig(MultirotorConfig): def __init__(self): # Stage prefix of the vehicle when spawning in the world self.stage_prefix = "quadrotor" # The USD file that describes the visual aspect of the vehicle (and some properties such as mass and moments of inertia) self.usd_file = ROBOTS["Iris"] # The default thrust curve for a quadrotor and dynamics relating to drag self.thrust_curve = QuadraticThrustCurve() self.drag = LinearDrag([0.50, 0.30, 0.0]) # The default sensors for a quadrotor self.sensors = [Barometer(), IMU(), Magnetometer(), GPS()] # The backends for actually sending commands to the vehicle. By default use mavlink (with default mavlink configurations) # [Can be None as well, if we do not desired to use PX4 with this simulated vehicle]. It can also be a ROS2 backend # or your own custom Backend implementation! self.backends = [MavlinkBackend()] class Iris(Multirotor): def __init__(self, id: int, world, init_pos=[0.0, 0.0, 0.07, init_orientation=[0.0, 0.0, 0.0, 1.0]], config=IrisConfig()): super.__init__(config.stage_prefix, config.usd_file, id, world, init_pos, init_orientation, config=config)	1,850	Python	42.046511	129	0.721081
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/drag.py	""" | File: drag.py | Author: Marcelo Jacinto ([email protected]) | Description: Base interface used to implement forces that should actuate on a rigidbody such as linear drag | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from pegasus.simulator.logic.state import State class Drag: """ Class that serves as a template for the implementation of Drag forces that actuate on a rigid body """ def __init__(self): """ Receives as input the drag coefficients of the vehicle as a 3x1 vector of constants """ @property def drag(self): """The drag force to be applied on the body frame of the vehicle Returns: list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference frame, expressed in Newton (N) [dx, dy, dz] """ return [0.0, 0.0, 0.0] def update(self, state: State, dt: float): """Method that should be implemented to update the drag force to be applied on the body frame of the vehicle Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference """ return [0.0, 0.0, 0.0]	1,481	Python	36.049999	128	0.649561
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/logic/dynamics/linear_drag.py	""" | File: linear_drag.py | Author: Marcelo Jacinto ([email protected]) | Description: Computes the forces that should actuate on a rigidbody affected by linear drag | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ import numpy as np from pegasus.simulator.logic.dynamics.drag import Drag from pegasus.simulator.logic.state import State class LinearDrag(Drag): """ Class that implements linear drag computations afftecting a rigid body. It inherits the Drag base class. """ def __init__(self, drag_coefficients=[0.0, 0.0, 0.0]): """ Receives as input the drag coefficients of the vehicle as a 3x1 vector of constants Args: drag_coefficients (list[float]): The constant linear drag coefficients to used to compute the total drag forces affecting the rigid body. The linear drag is given by diag(dx, dy, dz) * [v_x, v_y, v_z] where the velocities are expressed in the body frame of the rigid body (using the FRU frame convention). """ # Initialize the base Drag class super().__init__() # The linear drag coefficients of the vehicle's body frame self._drag_coefficients = np.diag(drag_coefficients) # The drag force to apply on the vehicle's body frame self._drag_force = np.array([0.0, 0.0, 0.0]) @property def drag(self): """The drag force to be applied on the body frame of the vehicle Returns: list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference frame, expressed in Newton (N) [dx, dy, dz] """ return self._drag_force def update(self, state: State, dt: float): """Method that updates the drag force to be applied on the body frame of the vehicle. The total drag force applied on the body reference frame (FLU convention) is given by diag(dx,dy,dz) * R' * v where v is the velocity of the vehicle expressed in the inertial frame and R' * v = velocity_body_frame Args: state (State): The current state of the vehicle. dt (float): The time elapsed between the previous and current function calls (s). Returns: list: A list with len==3 containing the drag force to be applied on the rigid body according to a FLU body reference """ # Get the velocity of the vehicle expressed in the body frame of reference body_vel = state.linear_body_velocity # Compute the component of the drag force to be applied in the body frame self._drag_force = -np.dot(self._drag_coefficients, body_vel) return self._drag_force	2,762	Python	42.171874	128	0.663287
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/tests/test_hello_world.py	# NOTE: # omni.kit.test - std python's unittest module with additional wrapping to add suport for async/await tests # For most things refer to unittest docs: https://docs.python.org/3/library/unittest.html import omni.kit.test # Extnsion for writing UI tests (simulate UI interaction) import omni.kit.ui_test as ui_test # Import extension python module we are testing with absolute import path, as if we are external user (other extension) import pegasus.simulator # Having a test class dervived from omni.kit.test.AsyncTestCase declared on the root of module will make it auto-discoverable by omni.kit.test class Test(omni.kit.test.AsyncTestCase): # Before running each test async def setUp(self): pass # After running each test async def tearDown(self): pass # Actual test, notice it is "async" function, so "await" can be used if needed async def test_hello_public_function(self): result = pegasus.simulator.some_public_function(4) self.assertEqual(result, 256) async def test_window_button(self): # Find a label in our window label = ui_test.find("My Window//Frame/**/Label[*]") # Find buttons in our window add_button = ui_test.find("My Window//Frame/**/Button[*].text=='Add'") reset_button = ui_test.find("My Window//Frame/**/Button[*].text=='Reset'") # Click reset button await reset_button.click() self.assertEqual(label.widget.text, "empty") await add_button.click() self.assertEqual(label.widget.text, "count: 1") await add_button.click() self.assertEqual(label.widget.text, "count: 2")	1,669	Python	35.304347	142	0.683044
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/config/extension.toml	[package] # Semantic Versioning is used: https://semver.org/ version = "1.0.0" # Lists people or organizations that are considered the "authors" of the package. authors = ["Marcelo Jacinto"] # The title and description fields are primarily for displaying extension info in UI title = "Pegasus Simulator" description="Extension providing the main framework interfaces for simulating aerial vehicles using PX4, Python or ROS 2 as a backend" # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" # URL of the extension source repository. repository = "" # One of categories for UI. category = "Simulation" # Keywords for the extension keywords = ["drone", "quadrotor", "multirotor", "UAV", "px4", "sitl", "robotics"] # Location of change log file in target (final) folder of extension, relative to the root. # More info on writing changelog: https://keepachangelog.com/en/1.0.0/ changelog="docs/CHANGELOG.md" # Preview image and icon. Folder named "data" automatically goes in git lfs (see .gitattributes file). # Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image. preview_image = "data/preview.png" # Icon is shown in Extensions window, it is recommended to be square, of size 256x256. icon = "data/icon.png" # Use omni.ui to build simple UI [dependencies] "omni.ui" = {} "omni.usd" = {} "omni.kit.uiapp" = {} "omni.isaac.core" = {} "omni.ui.scene" = {} "omni.kit.window.viewport" = {} # Main python module this extension provides, it will be publicly available as "import pegasus.simulator". [[python.module]] name = "pegasus.simulator" [python.pipapi] requirements = ["numpy", "scipy", "pymavlink", "pyyaml"] use_online_index = true [[test]] # Extra dependencies only to be used during test run dependencies = [ "omni.kit.ui_test" # UI testing extension ]	1,885	TOML	32.087719	134	0.731565
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/config/configs.yaml	global_coordinates: altitude: 90.0 latitude: 38.736832 longitude: -9.137977 px4_dir: ~/PX4-Autopilot px4_default_airframe: gazebo-classic_iris # Change to 'iris' if using PX4 version lower than v1.14	205	YAML	33.333328	98	0.756098
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/docs/CHANGELOG.md	# Changelog The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ## [1.0.0] - 2023-02-17 - Initial version of Pegasus Simulator extension ### Added - A widget GUI to spawn a limited set of simulation environments and drones using the PX4-bakend. - A powerful sensors, drag, thrusters, control and vehicle API. - Barometer, IMU, magnetometer and GPS sensors. - Linear drag model. - Quadratic thrust curve model. - Multirotor model. - The 3DR Iris quadrotor simulation model. - MAVLink communications control support. - ROS 2 communications control support (needs fixing). - A library for implementing rotations from NED to ENU and FLU to FRD frame conventions. - Examples on how to use the framework in standalone scripting mode. - Demo with a nonlinear controller implemented in python. - A PX4 tool for automatically launching PX4 in SITL mode when provided with the PX4-Autopilot installation directory. - A paper describing the motivation for this framework and its inner-workings. - Basic documentation generation using sphinx.	1,063	Markdown	43.333332	118	0.780809
PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/docs/README.md	# Pegasus Simulator Pegasus Simulator is a framework built on top of NVIDIA Omniverse and Isaac Sim. It is designed to provide an easy, yet powerfull way of simulating the dynamics of vehicles. It provides a simulation interface for PX4 integration as well as a custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions. ## Contributing The developers of the Pegasus simulator welcome any positive contributions and ideas from the robotics comunity to make in order to allow this extension to mature. If you think you have a nice contribution to make or just a simple suggestion, feel free to create bug reports, feature requests or open pull requests for direct code contributions. ## Acknowledgement NVIDIA Isaac Sim is available freely under https://www.nvidia.com/en-us/omniverse/download/. Pegasus Simulator is released under BSD-3 License. The license files of its dependencies and assets are present in the docs/licenses directory. ## Citation Please cite if you use this extension in your work: ``` @misc{jacinto2023pegasus, author = {Marcelo Jacinto and Rita Cunha}, title = {Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation}, year = {2023}, eprint = {}, } ``` ## Main Developer Team This simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027. * Project Founder * Marcelo Jacinto], under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon) * Architecture * Marcelo Jacinto * João Pinto * Multirotor Dynamic Simulation and Control * Marcelo Jacinto * Example Applications * Marcelo Jacinto * João Pinto * Paper Writting and Revision * Marcelo Jacinto * João Pinto * Rita Cunha * António Pascoal	2,036	Markdown	39.739999	324	0.783399
PegasusSimulator/PegasusSimulator/docs/index.rst	Pegasus Simulator ################# Overview ======== **Pegasus Simulator** is a framework built on top of `NVIDIA Omniverse <https://docs.omniverse.nvidia.com/>`__ and `Isaac Sim <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/overview.html>`__. It is designed to provide an easy yet powerful way of simulating the dynamics of multirotors vehicles. It provides a simulation interface for `PX4 <https://px4.io/>`__ integration as well as custom python control interface. At the moment, only multirotor vehicles are supported, with support for other vehicle topologies planned for future versions. .. raw:: html <p align = "center"> <a href="https://youtu.be/_11OCFwf_GE" target="_blank"><img src="_static/pegasus_cover.png" alt="Pegasus Simulator image" align="center" height="50"/></a> <a href="https://youtu.be/_11OCFwf_GE" target="_blank"><img src="_static/mini demo.gif" alt="Pegasus Simulator gif" align="center" height="50"/></a> </p> If you find ``Pegasus Simulator`` useful in your academic work, please cite the paper below. It is also available `here <https://arxiv.org/abs/2307.05263>`_. .. code-block:: bibtex @misc{jacinto2023pegasus, title={Pegasus Simulator: An Isaac Sim Framework for Multiple Aerial Vehicles Simulation}, author={Marcelo Jacinto and João Pinto and Jay Patrikar and John Keller and Rita Cunha and Sebastian Scherer and António Pascoal}, year={2023}, eprint={2307.05263}, archivePrefix={arXiv}, primaryClass={cs.RO} } Developer Team ~~~~~~~~~~~~~~ This simulation framework is an open-source effort, started by me, Marcelo Jacinto in January/2023. It is a tool that was created with the original purpose of serving my Ph.D. workplan for the next 4 years, which means that you can expect this repository to be mantained, hopefully at least until 2027. - Project Founder - `Marcelo Jacinto <https://github.com/MarceloJacinto>`__, under the supervision of Prof. Rita Cunha and Prof. Antonio Pascoal (IST/ISR-Lisbon) - Architecture - `Marcelo Jacinto <https://github.com/MarceloJacinto>`__ - `João Pinto <https://github.com/jschpinto>`__ - Multirotor Dynamic Simulation and Control - `Marcelo Jacinto <https://github.com/MarceloJacinto>`__ - Example Applications - `Marcelo Jacinto <https://github.com/MarceloJacinto>`__ - `João Pinto <https://github.com/jschpinto>`__ .. toctree:: :maxdepth: 2 :caption: Getting Started source/setup/installation source/setup/developer .. toctree:: :maxdepth: 1 :caption: Tutorials source/tutorials/run_extension_mode source/tutorials/create_standalone_application source/tutorials/create_standalone_simulation source/tutorials/create_custom_backend .. toctree:: :maxdepth: 2 :caption: Features source/features/environments source/features/vehicles source/features/px4_integration .. toctree:: :maxdepth: 2 :caption: Source API source/api/index .. toctree:: :maxdepth: 1 :caption: References source/references/contributing source/references/known_issues source/references/changelog source/references/roadmap source/references/license source/references/bibliography .. automodule::"pegasus_isaac" :platform: Linux-x86_64 :members: :undoc-members: :show-inheritance: :imported-members: :exclude-members: contextmanager Other Simulation Frameworks =========================== In this section, we acknowledge the nobel work of those who came before us and inspired this work: - :cite:p:`gazebo` Gazebo simulator - :cite:p:`rotorS` RotorS simulation plugin for gazebo - :cite:p:`px4` PX4-SITL simulation plugin for gazebo - :cite:p:`airsim` Microsoft Airsim project for Unreal Engine - :cite:p:`flightmare` Flightmare simulator for Unity - :cite:p:`jmavsim` jMAVSim java simulator *"If I have seen further than others, it is by standing upon the shoulders of giants."*, Sir Isaac Newton Project Sponsors ================ - Dynamics Systems and Ocean Robotics (DSOR) group of the Institute for Systems and Robotics (ISR), a research unit of the Laboratory of Robotics and Engineering Systems (LARSyS). - Instituto Superior Técnico, Universidade de Lisboa The work developed by Marcelo Jacinto and João Pinto was supported by Ph.D. grants funded by Fundação para as Ciências e Tecnologias (FCT). .. raw:: html <p float="left" align="center"> <img src="_static/dsor_logo.png" width="90" align="center" /> <img src="_static/logo_isr.png" width="200" align="center"/> <img src="_static/larsys_logo.png" width="200" align="center"/> <img src="_static/ist_logo.png" width="200" align="center"/> <img src="_static/logo_fct.png" width="200" align="center"/> </p>	4,770	reStructuredText	35.984496	302	0.713417
PegasusSimulator/PegasusSimulator/docs/conf.py	# Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # This section is responsible for auto-generating the API documentation import os import sys sys.path.insert(0, os.path.abspath("../extensions/pegasus.simulator")) sys.path.insert(0, os.path.abspath("../extensions/pegasus.simulator/pegasus/simulator")) # -- Project information ----------------------------------------------------- project = "Pegasus Simulator" copyright = "2023, Marcelo Jacinto" author = "Marcelo Jacinto" version = "1.0.0" # -- General configuration --------------------------------------------------- extensions = [ "sphinx.ext.duration", "sphinx.ext.doctest", "sphinx.ext.autodoc", "autodocsumm", 'sphinx.ext.napoleon', #"sphinx.ext.autosummary", "sphinx.ext.intersphinx", "myst_parser", "sphinx.ext.mathjax", "sphinxcontrib.bibtex", "sphinx.ext.todo", "sphinx.ext.githubpages", "sphinx.ext.autosectionlabel", "sphinxcontrib.youtube", "myst_parser" ] intersphinx_mapping = { "rtd": ("https://docs.readthedocs.io/en/stable/", None), "python": ("https://docs.python.org/3/", None), "sphinx": ("https://www.sphinx-doc.org/en/master/", None), } # mathjax hacks mathjax3_config = { "tex": { "inlineMath": [["\\(", "\\)"]], "displayMath": [["\\[", "\\]"]], }, } intersphinx_disabled_domains = ["std"] # supported file extensions for source files #source_suffix = { # ".rst": "restructuredtext" #} templates_path = ["_templates"] suppress_warnings = ["myst.header", "autosectionlabel.*"] # -- Options for EPUB output epub_show_urls = "footnote" # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "README.md", "licenses/*"] # --- Automatic API documentation generation # put type hints inside the description instead of the signature (easier to read) autodoc_typehints = "description" autodoc_typehints_description_target = "documented" # document class *and* __init__ methods autoclass_content = "class" # # separate class docstring from __init__ docstring autodoc_class_signature = "separated" # sort members by source order autodoc_member_order = "groupwise" # default autodoc settings autodoc_default_options = { "autosummary": True, } # BibTeX configuration bibtex_bibfiles = ["bibliography.bib"] # Generate documentation for __special__ methods napoleon_include_special_with_doc = True # Mock out modules that are not available on RTD autodoc_mock_imports = [ "np", "torch", "numpy", "scipy", "carb", "pxr", "omni", "omni.kit", "omni.usd", "omni.isaac.core.utils.nucleus", "omni.client", "pxr.PhysxSchema", "pxr.PhysicsSchemaTools", "omni.replicator", "omni.isaac.core", "omni.isaac.kit", "omni.isaac.cloner", "gym", "stable_baselines3", "rsl_rl", "rl_games", "ray", "h5py", "hid", "prettytable", "pyyaml", "pymavlink", "rclpy", "std_msgs", "sensor_msgs", "geometry_msgs" ] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. html_theme = "sphinx_rtd_theme" # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] html_logo = "_static/logo.png" html_theme_options = { 'logo_only': True, 'display_version': False, 'style_nav_header_background': '#FFD700' } html_show_copyright = True html_show_sphinx = False # The master toctree document. master_doc = "index"	4,372	Python	26.853503	88	0.645014
PegasusSimulator/PegasusSimulator/docs/licenses/assets/iris-license.rst	| **Author:** Lorenz Meier ([email protected]) and Thomas Gubler | **Description:** The original model has been created by Thomas Gubler. The original model can be found at `PX4 SITL Gazebo <https://github.com/PX4/PX4-SITL_gazebo-classic/>`__. .. code-block:: text BSD 3-Clause License Copyright (c) 2012 - 2023, PX4 Development Team All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	1,836	reStructuredText	53.02941	178	0.776688
PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_standalone_application.rst	Create a Standalone Application =============================== This tutorial introduces how to create a standalone python script to set up an empty scene. It introduces the main class used by ``Isaac Sim`` simulator, :class:`SimulationApp`, as well as the :class:`timeline` concept that helps to launch and control the simulation timeline. In this tutorial we do **NOT** expose the ``Pegasus API`` yet. 1. Code ------- The tutorial corresponds to the ``0_template_app.py`` example in the ``examples`` directory. .. literalinclude:: ../../../examples/0_template_app.py :language: python :emphasize-lines: 11-16,35-54,85-102 :linenos: 2. Explanation -------------- The first step, when creating a ``standalone application`` with ``Isaac Sim`` is to instantiate the :class:`SimulationApp` object, and it takes a dictionary of parameters that can be used to configure the application. This object will be responsible for opening a ``bare bones`` version of the simulator. The ``headless`` parameter selects whether to launch the GUI window or not. .. literalinclude:: ../../../examples/0_template_app.py :language: python :lines: 11-16 :linenos: :lineno-start: 11 .. note:: You can **NOT** import other omniverse modules before instantiating the :class:`SimulationApp`, otherwise the simulation crashes before the window it's even open. For a deeper understanding on how the :class:`SimulationApp` works, check `NVIDIA's offical documentation <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.kit/docs/index.html#simulation-application-omni-isaac-kit>`__. In order to create a `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__, we resort to the `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class environment. The `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class inherits the `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__, and provides already some default parameters for setting up a simulation for us. You can pass as arguments the physics time step and rendering time step (in seconds). The rendering and physics can be set to run at different rates. For now let's use the defaults: 60Hz for both rendering and physics. After creating the `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class environment. The `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class inherits the `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__, we will take advantage of its ``callback system`` to declare that some functions defined by us should be called at every physics iteration, render iteration or every time there is a timeline event, such as pressing the start/stop button. In this case, the ``physics_callback`` method will be invoked at every physics step, the ``render_callback`` at every render step and ``timeline_callback`` every time there is a timeline event. You can add as many callbacks as you want. After having all your callbacks defined, the ``world.reset()`` method should be invoked to initialize the ``physics context`` and set any existing robot joints (in this case there is none) to their default state. .. literalinclude:: ../../../examples/0_template_app.py :language: python :lines: 35-54 :linenos: :lineno-start: 35 To start the actual simulation, we invoke the timeline's ``play()`` method. This is necessary in order to ensure that every previously defined callback gets invoked. In order for the ``Isaac Sim`` app to remain responsive, we need to create a ``while loop`` that invokes ``world.step(render=True)`` to make sure that the UI get's rendered. .. literalinclude:: ../../../examples/0_template_app.py :language: python :lines: 85-102 :linenos: :lineno-start: 85 As you may have noticed, our ``infinite loop`` is very clean. In this work, similarly to the ROS 2 standard, we prefer to perform all the logic by resorting to function callbacks instead of cramming all the logic inside the while loop. This structure allows our code to be more organized and more modular. As you will learn in the following tutorials, the ``Pegasus Simulator API`` is built on top of this idea of ``callbacks``. 3. Execution ------------ Now let's run the Python script: .. code:: bash ISAACSIM_PYTHON examples/0_template_app.py This should open a stage with a blue ground-plane. The simulation should start playing automatically and the stage being rendered. To stop the simulation, you can either ``close the window``, press the ``STOP button`` in the UI, or press ``Ctrl+C`` in the terminal. .. note:: Notice that the window will only close when pressing the ``STOP button``, because we defined a method called ``timeline_callback`` that get's invoked for every ``timeline event``, such as pressing the ``STOP button``.	5,524	reStructuredText	60.388888	537	0.750181
PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_standalone_simulation.rst	Your First Simulation ===================== In this tutorial, you will create a standalone Python application to perform a simulation using 1 vehicle and ``PX4-Autopilot``. The end result should be the equivalent to the :ref:`Run in Extension Mode (GUI)` tutorial. To achieve this, we will cover the basics of the Pegasus Simulator :ref:`API Reference`. 0. Preparation -------------- Before you proceed, make sure you have read the :ref:`Installing the Pegasus Simulator` section first and that your system is correctly configured. Also, we will assume that you already followed the :ref:`Create a Standalone Application` tutorial, as in this tutorial we will resort to concepts introduced in it. Additionally, you will also be required to have ``QGroundControl`` installed to operate the simulated vehicle. If you haven't already, follow the Preparation section in the :ref:`Run in Extension Mode (GUI)` tutorial. 1. Code -------- The tutorial corresponds to the ``1_px4_single_vehicle.py`` example in the ``examples`` directory. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :emphasize-lines: 24-29,47-48,55-56,58-77,79-80 :linenos: 2. Explanation --------------- In order to start using the functionalities provided by the ``Pegasus Simulator``, we import some of the most commonly used classes from the ``pegasus.simulator.logic`` module, which contains all the core APIs. To check all the classes and methods currently provided, please refer to the :ref:`API Reference` section. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :lines: 24-29 :linenos: :lineno-start: 24 .. note:: Some APIs may not be documented in the :ref:`API Reference` section. This means one of three things: i) they are not meant for public use; ii) under development (untested); iii) or just deprecated and about to be replaced. Next, we initialize the :class:`PegasusInterface` object. This is a singleton, which means that there exists only one :class:`PegasusInterface` in memory at any time. This interface creates a `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class environment. The `World <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html?highlight=world#omni.isaac.core.world.World>`__ class inherits the `Simulation Context <https://docs.omniverse.nvidia.com/py/isaacsim/source/extensions/omni.isaac.core/docs/index.html#module-omni.isaac.core.simulation_context>`__ internally, so you do not need to declare your own manually when using this API. By default, when physics engine is set to run at ``250 Hz`` and the render engine at ``60Hz``. The :class:`PegasusInterface` provides methods to set the simulation environment, define the geographic coordinates of the origin of the world, setting the default path for the PX4-Autopilot installation and much more. To learn more about this class, refer to the :ref:`Pegasus Interface` API section. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :lines: 47-48 :linenos: :lineno-start: 47 Next, we load the 3D world environment. For this purpose, we provide the auxiliary method ``load_environment(usd_file)`` for loading pre-made environments stored in `Universal Scene Description (.usd) <https://developer.nvidia.com/usd>`__ files. In this example, we load one of the simulation environments already provided by NVIDIA, whose path in stored in the ``SIMULATION_ENVIRONMENTS`` dictionary. To known all provided environments, check the :ref:`Params` API section. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :lines: 55-56 :linenos: :lineno-start: 55 The next step is to create a multirotor vehicle object. For that we start by creating a ``MultirotorConfig``, which contains by default a :class:`QuadraticThrustCurve`, :class:`Linear Drag` model, a list of ``Sensors`` composed of a :class:`GPS`, :class:`IMU`, :class:`Magnetometer` and :class:`Barometer`, and a list of control :class:`Backend`. In this tutorial, we whish to control the vehicle via ``MAVLink``, ``PX4-Autopilot`` and ``QGroundControl``. Therefore, we create a ``MAVLink`` control backend configured to also launch ``PX4-Autopilot`` in SITL mode in the background. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :lines: 58-68 :linenos: :lineno-start: 58 To create the actual ``Multirotor`` object, we must specify the ``stage_path``, i.e. the name that the vehicle will have inside the simulation tree and the ``usd_path`` which defines where the 3D model of the vehicle is stored. Once again, to known all provided vehicle models, check the :ref:`Params` API section. Additionally, we can provide the original position and orientation of the vehicle, according to an East-North-DOWN (ENU) convention. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :lines: 70-77 :linenos: :lineno-start: 70 After the simulation is setup, the ``world.reset()`` method should be invoked to initialize the ``physics context`` and set any existing robot joints (the multirotor rotor joints) to their default state. .. literalinclude:: ../../../examples/1_px4_single_vehicle.py :language: python :lines: 79-80 :linenos: :lineno-start: 79 3. Execution ------------ Now let's run the Python script: .. code:: bash ISAACSIM_PYTHON examples/1_px4_single_vehicle.py This should open a stage with a blue ground-plane with an 3DR Iris vehicle model in it. The simulation should start playing automatically and the stage being rendered. PX4-Autopilot will start running automatically in the background, receiving data from the simulated sensors and sending target angular velocities for the vehicle rotors. You can now play with the vehicle using ``QGroundControl`` similarly to what was shown in :ref:`Run in Extension Mode (GUI)` tutorial. To stop the simulation, you can either ``close the window``, press the ``STOP button`` in the UI, or press ``Ctrl+C`` in the terminal.	6,234	reStructuredText	50.958333	583	0.742862
PegasusSimulator/PegasusSimulator/docs/source/tutorials/create_custom_backend.rst	Create a Custom Controller ========================== In this tutorial, you will learn how to create a custom ``control backend`` that receives the current state of the vehicle and its sensors and computes the control inputs to give to the rotors of the drone. The control laws implemented in this tutorial and the math behind them are well described in :cite:p:`Pinto2021`, :cite:p:`mellinger_kumar`. In this tutorial we will endup with a simulation that does **NOT** use ``PX4-Autopilot`` , and instead will use a custom nonlinear controller to make the vehicle follow a pre-determined trajectory, written in just a few lines of pure Python code. .. note:: The Control Backend API is what was used to implement the MAVLink/PX4 backend. This interface is very powerful as it not only allows the user to create custom communication protocols (such as ROS) for controlling the vehicle, as well as defining and testing new control algorithms directly in pure Python code. This is specially usefull for conducting MATLAB-like simulations, as we can implement and test algorithms directly in a 3D environment by writing a few lines of Python code without having to deal with `Mavlink`, `PX4` or `ROS` like in other simulators. 0. Preparation -------------- This tutorial assumes that you have followed the :ref:`Your First Simulation` section first. 1. Code ------- The tutorial corresponds to the ``4_python_single_vehicle.py`` example in the ``examples`` directory. .. literalinclude:: ../../../examples/4_python_single_vehicle.py :language: python :emphasize-lines: 30-31,68-75 :linenos: The next code section corresponds to the ``nonlinear_controller.py`` in the ``examples/utils`` directory. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :emphasize-lines: 18,24-44,114-117,121-124,143-151,154-160,168-174,177-183 :linenos: 2. Explanation -------------- To start a pre-programed simulation using a different control backend other than ``MAVLink`` we include our custom ``control backend`` module written in pure Python. .. literalinclude:: ../../../examples/4_python_single_vehicle.py :language: python :lines: 30-31 :linenos: :lineno-start: 30 We now create a multirotor configuration and set the multirotor backend to be our ``NonlinearController`` object. That's it! It is that simple! Instead of using the `MAVLink/PX4`` control we will use a pure Python controller written by us. The rest of the script is the same as in the previous tutorial. .. literalinclude:: ../../../examples/4_python_single_vehicle.py :language: python :lines: 68-75 :linenos: :lineno-start: 68 Now, let's take a look on how the ``NonlinearControl`` class is structured and how you can build your own. We must start by including the ``Backend`` class found in the ``pegasus.simulator.logic.backends`` API. To explore all the functionalities offered by this class, check the :ref:`Backend` API reference page. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 18 :linenos: :lineno-start: 18 Next, we define a class that inherits the `Backend`` class. This class must implement a few methods to be compliant with the ``Multirotor`` API. In this example we will implement an "hard-coded" nonlinear geometrical controller for the multirotor to track a pre-defined trajectory. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 24-44 :linenos: :lineno-start: 24 The first method that should be implemented is ``start()`` . This method gets invoked by the vehicle when the simulation starts. You should perform any initialization of your algorithm or communication protocol here. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 114-117 :linenos: :lineno-start: 114 The ``stop()`` method gets invoked by the vehicle when the simulation stops. You should perform any cleanup here. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 121-124 :linenos: :lineno-start: 121 The ``update_sensor(sensor_type: str, data)`` method gets invoked by the vehicle at every physics step iteration (it is used as a callback) for each sensor that generated output data. It receives as input a string which describes the type of sensor and the data produced by that sensor. It is up to you to decide on how to parse the sensor data and use it. In this case we are not going to use the data produced by the simulated sensors for our controller. Instead we will get the state of the vehicle directly from the simulation and use that to feedback into our control law. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 143-151 :linenos: :lineno-start: 143 .. note:: You can take a look on how the ``MavlinkBackend`` is implemented to check on how to parse sensor data produced by IMU, GPS, etc. A simple strategy is to use an if-statement to check for which sensor we are receive the data from and parse it accordingly, for example: .. code:: Python if sensor_type == "imu": # do something elif sensor_type == "gps": # do something else else: # some sensor we do not care about, so ignore Check the Sensors :ref:`API Reference` to check what type of data each sensor generates. For most cases, it will be a dictionary. The ``update_state(state: State)`` method is called at every physics steps with the most up-to-date ``State`` of the vehicle. The state object contains: - **position** of the vehicle's body frame with respect to the inertial frame, expressed in the inertial frame; - **attitude** of the vehicle's body frame with respect to the inertial frame, expressed in the inertial frame; - **linear velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the inertial frame; - **linear body-velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the vehicle's body frame; - **angular velocity** of the vehicle's body frame, with respect to the inertial frame, expressed in the vehicle's body frame; - **linear acceleration** of the vehicle's body frame, with respect to the inertial frame, expressed in the inertial frame. All of this data is filled adopting a **East-North-Down (ENU)** convention for the Inertial Reference Frame and a **Front-Left-Up (FLU)** for the vehicle's body frame of reference. .. note:: In case you need to adopt other conventions, the ``State`` class also provides methods to return the state of the vehicle in North-East-Down (NED) and Front-Right-Down (FRD) conventions, so you don't have to make those conversions manually. Check the :ref:`State` API reference page for more information. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 154-160 :linenos: :lineno-start: 154 The ``input_reference()`` method is called at every physics steps by the vehicle to retrieve from the controller a list of floats with the target angular velocities in [rad/s] to use as reference to apply to each vehicle rotor. The list of floats returned by this method should have the same length as the number of rotors of the vehicle. .. note:: In order to have a general controller, you might not want to hard-code the number of rotors of the vehicle in the controller. To take this into account, the :ref:`Backend` object is initialized with a reference to the :ref:`Vehicle` object when this gets instantiated. Therefore, it will access to all of its attributes, such as the number of rotors and methods to convert torques and forces in the body-frame to target rotor angular velocities! .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 168-174 :linenos: :lineno-start: 168 The ``update(dt: float)`` method gets invoked at every physics step by the vehicle. It receives as argument the amount of time elapsed since the last update (in seconds). This is where you should define your controller/communication layer logic and update the list of reference angular velocities for the rotors. .. literalinclude:: ../../../examples/utils/nonlinear_controller.py :language: python :lines: 177-183 :linenos: :lineno-start: 177 3. Execution ------------ Now let's run the Python script: .. code:: bash ISAACSIM_PYTHON examples/4_python_single_vehicle.py This should open a stage with a blue ground-plane with an 3DR Iris vehicle model in it. The simulation should start playing automatically and the stage being rendered. The vehicle will automatically start flying and performing a very fast relay maneuvre. If you miss it, you can just hit the stop/play button again to repeat it. Notice now, that unlike the previous tutorial, if you open ``QGroundControl`` you won't see the vehicle. This is normal, because now we are not using the ``MAVLink`` control backend, but instead our custom ``NonlinearControl`` backend.	9,195	reStructuredText	45.444444	168	0.737575
PegasusSimulator/PegasusSimulator/docs/source/tutorials/run_extension_mode.rst	Run in Extension Mode (GUI) ======================================= This tutorial introduces how to interface with the Pegasus Simulator working in extension mode, i.e. with an interactive GUI. This means that ``ISAACSIM`` will be launched as a standard application and the Pegasus Simulator extension should be enabled from the extension manager. 0. Preparation -------------- Before you proceed, check the :ref:`Installing the Pegasus Simulator` section first, if you haven't already. You will also require `QGroundControl <http://qgroundcontrol.com/>`__ to control the vehicle. You haven't download it yet, you can do it `here <https://docs.qgroundcontrol.com/master/en/getting_started/download_and_install.html>`__ or follow these steps: 1. Open a new terminal and run: .. code:: bash sudo usermod -a -G dialout $USER sudo apt-get remove modemmanager -y sudo apt install gstreamer1.0-plugins-bad gstreamer1.0-libav gstreamer1.0-gl -y sudo apt install libqt5gui5 -y sudo apt install libfuse2 -y 2. Download the `QGroundControl App Image <https://d176tv9ibo4jno.cloudfront.net/latest/QGroundControl.AppImage>`__. 3. Make the App image executable .. code:: bash chmod +x ./QGroundControl.AppImage 4. Execute QGroundControl by double-clicking or running: .. code:: bash ./QGroundControl.AppImage 1. Simulation Steps ------------------- 1. Open ``ISAACSIM``, either by using the Omniverse Launcher or the terminal command: .. code:: bash ISAACSIM 2. Make sure the Pegasus Simulator Extension is enabled. .. image:: /_static/pegasus_inside_extensions_menu.png :width: 600px :align: center :alt: Enable the Pegasus Simulator extension inside Isaac Sim 3. On the Pegasus Simulator tab in the bottom-right corner, click on the ``Load Scene`` button. .. image:: /_static/tutorials/load_scene.png :width: 600px :align: center :alt: Load a 3D Scene 4. Again, on the Pegasus Simulator tab, click on the ``Load Vehicle`` button. .. image:: /_static/tutorials/load_vehicle.png :width: 600px :align: center :alt: Load the vehicle 5. Press the ``play`` button on the simulator's control bar on the left corner. .. image:: /_static/tutorials/play.png :width: 600px :align: center :alt: Start the simulation environment 6. On QGroundControl, an arrow representing the vehicle should pop-up. You can now perform a take-off, but pressing the ``take-off`` button on top-left corner of QGroundControl. .. image:: /_static/tutorials/take_off.png :width: 600px :align: center :alt: Perform a take-off with the drone 7. On QGroundControl, left-click on a place on the map, press ``Go to location`` and slide at the bottom of the screen to confirm the target waypoint for the drone to follow. .. image:: /_static/tutorials/go_to_location.png :width: 600px :align: center :alt: Perform a go-to waypoint with the drone Congratulations 🎉️🎉️🎉️ ! You have just completed your first tutorial and you should now see the vehicle moving on the screen. A short video of this tutorial is also available `here <https://youtu.be/_11OCFwf_GE>`__. .. youtube:: _11OCFwf_GE :width: 100% :align: center :privacy_mode: .. note:: Everything that you can do using the provided GUI can also be achieved by the Pegasus Simulator API in Python. In the next tutorials we will cover how to create standalone Python scripts to perform simulations.	3,619	reStructuredText	33.807692	126	0.682233
PegasusSimulator/PegasusSimulator/docs/source/setup/installation.rst	Installation ============ Installing NVIDIA Isaac Sim --------------------------- .. image:: https://img.shields.io/badge/IsaacSim-2023.1.1-brightgreen.svg :target: https://developer.nvidia.com/isaac-sim :alt: IsaacSim 2023.1.1 .. image:: https://img.shields.io/badge/PX4--Autopilot-1.14.1-brightgreen.svg :target: https://github.com/PX4/PX4-Autopilot :alt: PX4-Autopilot 1.14.1 .. image:: https://img.shields.io/badge/Ubuntu-22.04LTS-brightgreen.svg :target: https://releases.ubuntu.com/22.04/ :alt: Ubuntu 22.04 .. note:: We have tested Pegasus Simulator with Isaac Sim 2023.1.1 release on Ubuntu 22.04LTS with NVIDIA driver 545.23.08. The PX4-Autopilot used during development was v.14.1. Older versions Ubuntu and PX4-Autopilot were not tested. This extension was not tested on Windows. In order to install Isaac Sim on linux, download the `Omniverse AppImage here <https://install.launcher.omniverse.nvidia.com/installers/omniverse-launcher-linux.AppImage>`__ or run the following line on the terminal: .. code:: bash wget https://install.launcher.omniverse.nvidia.com/installers/omniverse-launcher-linux.AppImage A short video with the installation guide for Pegasus Simulator is also available `here <https://youtu.be/YCp5E8nazag>`__. .. youtube:: YCp5E8nazag :width: 100% :align: center :privacy_mode: Configuring the environment variables ------------------------------------- NVIDIA provides Isaac Sim with its own Python interpreter along with some basic extensions such as numpy and pytorch. In order for the Pegasus Simulator to work, we require the user to use the same python environment when starting a simulation from python scripts. As such, we recommend setting up a few custom environment variables to make this process simpler. .. note:: Although it is possible to setup a virtual environment following the instructions `here <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/install_python.html>`__, this feature was not tested. Start by locating the `Isaac Sim installation <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/install_python.html>`__ by navigating to Isaac Sim's root folder. Typically, in Linux, this folder can be found under ``${HOME}/.local/share/ov/pkg/isaac_sim-*``, where the ``*`` is the version number. Add the following lines to your ``~/.bashrc`` or ``~/.zshrc`` file. .. code:: bash # Isaac Sim root directory export ISAACSIM_PATH="${HOME}/.local/share/ov/pkg/isaac_sim-*" # Isaac Sim python executable alias ISAACSIM_PYTHON="${ISAACSIM_PATH}/python.sh" # Isaac Sim app alias ISAACSIM="${ISAACSIM_PATH}/isaac-sim.sh" If you only have one version of Isaac Sim installed, you can leave the ``*``, otherwise you will have to replace it by the version that you desire to use. In the remaining of the documentation, we will refer to the Isaac Sim's path as ``ISAACSIM_PATH`` , the provided python interpreter as ``ISAACSIM_PYTHON`` and the simulator itself as ``ISAACSIM`` . Running Isaac Sim ~~~~~~~~~~~~~~~~~ At this point, you are expected to have NVIDIA Isaac Sim fully installed and working. To make sure you have everything setup correctly, open a new terminal window (**Ctrl+Alt+T**), and test the following commands: - Check that the simulator app can be launched .. code:: bash # Run the simulator with the --help argument to see all available options ISAACSIM --help # Run the simulator. A new window should open ISAACSIM - Check that you can launch the simulator from a python script (standalone mode) .. code:: bash # Run the bundled python interpreter and see if it prints on the terminal "Hello World." ISAACSIM_PYTHON -c "print('Hello World.')" # Run the python interpreter and check if we can run a script that starts the simulator and adds cubes to the world ISAACSIM_PYTHON ${ISAACSIM_PATH}/standalone_examples/api/omni.isaac.core/add_cubes.py If you were unable to run the commands above successfuly, then something is incorrectly configured. Please do not proceed with this installation until you have everything setup correctly. Addtional Isaac Sim resources: - `Troubleshooting documentation <https://docs.omniverse.nvidia.com/app_isaacsim/prod_kit/linux-troubleshooting.html>`__ Installing the Pegasus Simulator -------------------------------- Clone the `Pegasus Simulator <https://www.github.com/PegasusSimulator/PegasusSimulator.git>`__: .. code:: bash # Option 1: With HTTPS git clone https://github.com/PegasusSimulator/PegasusSimulator.git # Option 2: With SSH (you need to setup a github account with ssh keys) git clone [email protected]:PegasusSimulator/PegasusSimulator.git The Pegasus Simulator was originally developed as an Isaac Sim extension with an interactive GUI, but also provides a powerfull API that allows it to run as a standalone app, i.e. by creating python scritps (as shown in the examples directory of this repository). To be able to use the extension in both modes, follow these steps: 1. Launch ``ISAACSIM`` application. 2. Open the Window->extensions on the top menubar inside Isaac Sim. .. image:: /_static/extensions_menu_bar.png :width: 600px :align: center :alt: Extensions on top menubar 3. On the Extensions manager menu, we can enable or disable extensions. By pressing the settings button, we can add a path to the Pegasus-Simulator repository. .. image:: /_static/extensions_widget.png :width: 600px :align: center :alt: Extensions widget 4. The path inserted should be the path to the repository followed by ``/extensions``. .. image:: /_static/ading_extension_path.png :width: 600px :align: center :alt: Adding extension path to the extension manager 5. After adding the path to the extension, we can enable the Pegasus Simulator extension on the third-party tab. .. image:: /_static/pegasus_inside_extensions_menu.png :width: 600px :align: center :alt: Pegasus Extension on the third-party tab When enabling the extension for the first time, the python requirements should be install automatically for the build in ``ISAACSIM_PYTHON`` , and after a few seconds, the Pegasus widget GUI should pop-up. 6. The Pegasus Simulator window should appear docked to the bottom-right section of the screen. .. image:: /_static/pegasus_gui_example.png :width: 600px :align: center :alt: Pegasus Extension GUI after install Installing the extension as a library ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In order to be able to use the Pegasus Simulator API from python scripts and standalone apps, we must install this extension as a ``pip`` python module for the built-in ``ISAACSIM_PYTHON`` to recognize. For that, run: .. code:: bash # Go to the repository of the pegasus simulator cd PegasusSimulator # Go into the extensions directory cd extensions # Run the pip command using the built-in python interpreter ISAACSIM_PYTHON -m pip install --editable pegasus.simulator We use the ``--editable`` flag so that the content of the extension is linked instead of copied. After this step, you should be able to run the python standalone examples inside the ``examples`` folder. Installing PX4-Autopilot ------------------------ In this first version of the Pegasus Simulator (in extension mode), the GUI widget provided is only usefull if you intend to use the PX4-Autopilot. To install PX4-Autopilot, follow the following steps: 1. Install the dependencies (to be able to compile PX4-Autopilot): .. code:: bash # Linux packages sudo apt install git make cmake python3-pip # Python packages pip install kconfiglib jinja2 empy jsonschema pyros-genmsg packaging toml numpy future 2. Clone the `PX4-Autopilot <https://github.com/PX4/PX4-Autopilot>`__: .. code:: bash # Option 1: With HTTPS git clone https://github.com/PX4/PX4-Autopilot.git # Option 2: With SSH (you need to setup a github account with ssh keys) git clone [email protected]:PX4/PX4-Autopilot.git 3. Checkout to the stable version 1.14.1 and compile the code for software-in-the-loop (SITL) mode: .. code:: bash # Go to the PX4 directory cd PX4-Autopilot # Checkout to the latest stable release git checkout v1.14.1 # Initiate all the submodules. Note this will download modules such as SITL-gazebo which we do not need # but this is the safest way to make sure that the PX4-Autopilot and its submodules are all checked out in # a stable and well tested release git submodule update --init --recursive # Compile the code in SITL mode make px4_sitl_default none Note: If you are installing a version of PX4 prior to v1.14.1, you may need to go to change the default airframe to be used by PX4. This can be achieved by: .. code:: bash # Go inside the config folder of the pegasus simulator extension cd PegasusSimulator/extensions/pegasus/simulator/config # Open the file configs.yaml nano configs.yaml # And change the line: px4_default_airframe: iris You can also set the PX4 installation path inside the Pegasus Simulator GUI, as shown in the next section, or by editing the file ``PegasusSimulator/extensions/pegasus/simulator/config/config.yaml`` and setting the ``px4_dir`` field to the correct path. Setting the PX4 path inside the Pegasus Simulator ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The simulator provides a feature to auto-launch PX4-Autopilot for every vehicle that is spawned in the simulation world. For this feature to work, we need to tell the Pegasus Simulator extension where the PX4-Autopilot directory can be found. For that, edit the ``PX4 Path`` text field if is not correct by default and press the ``Make Default`` button. This field supports relative paths to the home directory, which means that you can use ``~`` to represent the home directory without hard-coding it. .. image:: /_static/pegasus_GUI_px4_dir.png :width: 600px :align: center :alt: Pegasus GUI with px4 directory highlighted By default, the extension assumes that PX4-Autopilot is installed at ``~/PX4-Autopilot`` .	10,494	reStructuredText	40.482213	268	0.708691
PegasusSimulator/PegasusSimulator/docs/source/setup/developer.rst	Development =========== We developed this extension using `Visual Studio Code <https://code.visualstudio.com/>`__, the recommended tool on NVIDIA's Omniverse official documentation. To setup Visual Studio Code with hot-reloading features, follow the additional documentation pages: * `Isaac Sim VSCode support <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/manual_standalone_python.html#isaac-sim-python-vscode>`__ * `Debugging with VSCode <https://docs.omniverse.nvidia.com/app_isaacsim/app_isaacsim/tutorial_advanced_python_debugging.html>`__ To enable a better developer experience when contributing or modifying this extension, and have access to features such as autocomplete, we recommend linking the Pegasus Simulator repository to the current installation of ``ISAACSIM`` . For that, please run the following script provided with the framework: .. code:: bash ./link_app.sh --path $ISAACSIM_PATH This script will create a symbolic link to ``ISAACSIM`` inside the repository. After this step, you can also launch the ``ISAACSIM`` with the extension enabled (without using the GUI presented in Section :ref:`Installing the Pegasus Simulator`), by running: .. code:: bash ./app/isaac-sim.sh --ext-folder extensions --enable pegasus.simulator Code structure -------------- This simulation framework is strucuture according to the following tree: .. code:: bash PegasusSimulator: ├── .vscode ├── docs ├── examples ├── tools ├── extensions │   ├── pegasus.simulator │   │   ├── config │   │   ├── data │   │   ├── docs │   │   ├── setup.py │   │   ├── pegasus.simulator │   │   │   │   ├── __init__.py │   │   │   │   ├── params.py │   │   │   │   ├── extension.py │   │   │   │   ├── assets │   │   │   │   ├── logic │   │   │   │   ├── ui The extensions directory contains the source code for the PegasusSimulator API and interactive GUI while the examples directory contains the a set of python scripts to launch standalone applications and pre-programed simulations. As explained in NVIDIA's documentation, extensions are the standard way of developing on top of Isaac Sim and other Omniverse tools. The core of our extension is developed in the ``logic`` and the ``ui`` modules. The ``logic`` API is exposed to the users and is used both when operating the Pegasus Simulator in GUI widget/extension mode and via standalone python applications. The ``ui`` API is **not exposed/documented** as it is basically defines the widget to call functionalities provided by the ``logic`` module.	2,604	reStructuredText	42.416666	146	0.697005

---

Subsets and Splits

Run Query Ctrl+↵

• Saved Queries
• Top Community Queries

No community queries yet

The top public SQL queries from the community will appear here once available.