Datasets:

pe-nlp

/

ov-kit-code-files-v2-filtered

like 0

Follow

PE-NLP 14

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]

Markdown

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

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

Python

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.

Markdown

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

C++

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)

C++

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(); }

C++

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); } } } }

C++

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; }

C++

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; };

C

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; };

C

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; };

C

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; };

C

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; };

C

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.

Markdown

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.

Markdown

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

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

Python

Vadim-Karpenko/omniverse-material-manager-extended/tools/packman/config.packman.xml

<config remotes="cloudfront"> <remote2 name="cloudfront"> <transport actions="download" protocol="https" packageLocation="d4i3qtqj3r0z5.cloudfront.net/${name}@${version}" /> </remote2> </config>

XML

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

from .extension import *

Python

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

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

Python

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

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

Python

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

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

Python

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", ]

TOML

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.

Markdown

zslrmhb/Omniverse-Virtual-Assisstant/nlp.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/tts.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/audio2face_streaming_utils.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/asr.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/main.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/config.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/audio2face_pb2_grpc.py

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

Python

zslrmhb/Omniverse-Virtual-Assisstant/audio2face.py

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

Python

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.

Markdown

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.

Markdown

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>

Markdown

PegasusSimulator/PegasusSimulator/examples/1_px4_single_vehicle.py

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

Python

PegasusSimulator/PegasusSimulator/examples/6_paper_results.py

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

Python

PegasusSimulator/PegasusSimulator/examples/3_ros2_single_vehicle.py

#!/usr/bin/env python """ | File: 3_ros2_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 ROS2 backend system. NOTE: this ROS2 interface only works on Ubuntu 22.04LTS and ROS2 Humble """ # 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.ros2_backend import ROS2Backend from pegasus.simulator.logic.graphs import ROS2Camera from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface # 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() config_multirotor.backends = [ROS2Backend(vehicle_id=1, config={"namespace": 'drone'})] config_multirotor.graphs = [ROS2Camera("body/Camera", config={"types": ['rgb', 'camera_info', 'depth_pcl', 'depth'], "namespace": 'drone1', "topic": 'camera', "tf_frame_id": 'map', 'resolution': [640, 480]})] Multirotor( "/World/quadrotor", ROBOTS['Iris'], 0, [0.0, 0.0, 0.07], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor, ) # Reset the simulation environment so that all articulations (aka robots) are initialized self.world.reset() # Auxiliar variable for the timeline callback example self.stop_sim = False def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running() and not self.stop_sim: # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/5_python_multi_vehicle.py

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

Python

PegasusSimulator/PegasusSimulator/examples/4_python_single_vehicle.py

#!/usr/bin/env python """ | File: 4_python_single_vehicle.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 # Import the Pegasus API for simulating drones from pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS 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 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 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"]) # 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_2.csv", results_file=self.curr_dir + "/results/single_statistics.npz", Ki=[0.5, 0.5, 0.5], Kr=[2.0, 2.0, 2.0] )] Multirotor( "/World/quadrotor1", ROBOTS['Iris'], 0, [2.3, -1.5, 0.07], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor1, ) # Reset the simulation environment so that all articulations (aka robots) are initialized self.world.reset() def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running(): # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/0_template_app.py

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

Python

PegasusSimulator/PegasusSimulator/examples/8_camera_vehicle.py

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

Python

PegasusSimulator/PegasusSimulator/examples/2_px4_multi_vehicle.py

#!/usr/bin/env python """ | File: 2_px4_multi_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 multiple vehicles, 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"]) # Spawn 5 vehicles with the PX4 control backend in the simulation, separated by 1.0 m along the x-axis for i in range(5): self.vehicle_factory(i, gap_x_axis=1.0) # 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 vehicle_factory(self, vehicle_id: int, gap_x_axis: float): """Auxiliar method to create multiple multirotor vehicles Args: vehicle_id (_type_): _description_ """ # 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": vehicle_id, "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'], vehicle_id, [gap_x_axis * vehicle_id, 0.0, 0.07], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor) def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running() and not self.stop_sim: # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/utils/nonlinear_controller.py

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

Python

PegasusSimulator/PegasusSimulator/tools/scripts/link_app.py

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

Python

PegasusSimulator/PegasusSimulator/tools/packman/config.packman.xml

<config remotes="cloudfront"> <remote2 name="cloudfront"> <transport actions="download" protocol="https" packageLocation="d4i3qtqj3r0z5.cloudfront.net/${name}@${version}" /> </remote2> </config>

XML

PegasusSimulator/PegasusSimulator/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 shutil import sys import tempfile import zipfile __author__ = "hfannar" logging.basicConfig(level=logging.WARNING, format="%(message)s") logger = logging.getLogger("install_package") class TemporaryDirectory: def __init__(self): self.path = None def __enter__(self): self.path = tempfile.mkdtemp() return self.path def __exit__(self, type, value, traceback): # Remove temporary data created shutil.rmtree(self.path) def install_package(package_src_path, package_dst_path): with zipfile.ZipFile(package_src_path, allowZip64=True) as zip_file, TemporaryDirectory() as temp_dir: zip_file.extractall(temp_dir) # Recursively copy (temp_dir will be automatically cleaned up on exit) try: # Recursive copy is needed because both package name and version folder could be missing in # target directory: shutil.copytree(temp_dir, package_dst_path) except OSError as exc: logger.warning("Directory %s already present, packaged installation aborted" % package_dst_path) else: logger.info("Package successfully installed to %s" % package_dst_path) install_package(sys.argv[1], sys.argv[2])

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

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

Python

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

Python

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)

Python

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

Python

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

Python

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)

Python

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

Python

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)

Python

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

Python

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

Python

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

Python

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"

Python

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

Python

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

Python

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

Python

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

Python

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

""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .sensor import Sensor from .barometer import Barometer from .gps import GPS from .imu import IMU from .magnetometer import Magnetometer

Python

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

Python

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

Python

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

Python

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

Python

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

""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .pegasus_interface import PegasusInterface

Python

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

Python

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

Python

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

Python

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)]

Python

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()

Python

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()

Python

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

Python

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

Python

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

""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .vehicle import Vehicle from .multirotor import Multirotor, MultirotorConfig

Python

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)

Python

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

""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ from .drag import Drag from .linear_drag import LinearDrag

Python

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]

Python

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

Python

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

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause from .test_hello_world import *

Python

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")

Python

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 ]

TOML

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

YAML