def __init__(self):
AttributesContainerBase.__init__(self)
attribute = self.define_attribute("CurrentFocalLength")
attribute.construct_usd_attribute = lambda camera: UsdGeom.Camera(
camera).GetFocalLengthAttr()
attribute.get_from_usd = lambda usd_node: usd_unreal.utils.get_usd_attribute_value(
usd_node.GetPrim(), "focalLength")
attribute.unreal_property_path = [
"camera_component", "current_focal_length"
]
attribute.get_from_actor = lambda actor: actor.camera_component.current_focal_length
attribute = self.define_attribute("ManualFocusDistance")
attribute.construct_usd_attribute = lambda camera: UsdGeom.Camera(
camera).GetFocusDistanceAttr()
attribute.get_from_usd = lambda usd_node: usd_unreal.utils.get_usd_attribute_value(
usd_node.GetPrim(), "focusDistance")
attribute.unreal_property_path = [
"camera_component", "focus_settings", "manual_focus_distance"
]
attribute.get_from_actor = lambda actor: actor.camera_component.focus_settings.manual_focus_distance
attribute = self.define_attribute("CurrentAperture")
attribute.construct_usd_attribute = lambda camera: UsdGeom.Camera(
camera).GetFStopAttr()
attribute.get_from_usd = lambda usd_node: usd_unreal.utils.get_usd_attribute_value(
usd_node.GetPrim(), "fStop")
attribute.unreal_property_path = [
"camera_component", "current_aperture"
]
attribute.get_from_actor = lambda actor: actor.camera_component.current_aperture
attribute = self.define_attribute("SensorWidth")
attribute.construct_usd_attribute = lambda camera: UsdGeom.Camera(
camera).GetHorizontalApertureAttr()
attribute.get_from_usd = lambda usd_node: usd_unreal.utils.get_usd_attribute_value(
usd_node.GetPrim(), "horizontalAperture")
attribute.unreal_property_path = [
"camera_component", "filmback", "sensor_width"
]
attribute.get_from_actor = lambda actor: actor.camera_component.filmback.sensor_width
attribute = self.define_attribute("SensorHeight")
attribute.construct_usd_attribute = lambda camera: UsdGeom.Camera(
camera).GetVerticalApertureAttr()
attribute.get_from_usd = lambda usd_node: usd_unreal.utils.get_usd_attribute_value(
usd_node.GetPrim(), "verticalAperture")
attribute.unreal_property_path = [
"camera_component", "filmback", "sensor_height"
]
attribute.get_from_actor = lambda actor: actor.camera_component.filmback.sensor_height
def test_AbcToUsd(self):
"""
Test conversion of an ABC camera to USD.
"""
# Open ABC file on USD stage and get camera
abcFile = 'testAbcCamera.abc'
self.assertTrue(abcFile)
stage = Usd.Stage.Open(abcFile)
self.assertTrue(stage)
cam = stage.GetPrimAtPath('/World/main_cam')
self.assertTrue(cam)
# Convert to Gf camera to check the frustum
gfCam = UsdGeom.Camera(cam).GetCamera(1.0)
expected = (
Gf.Vec3d(-4.27349785298, -2341.70939914119, -10.0),
Gf.Vec3d(4.27349785298, -2341.70939914119, -10.0),
Gf.Vec3d(-4.27349785298, -2338.29060085880, -10.0),
Gf.Vec3d(4.27349785298, -2338.29060085880, -10.0),
Gf.Vec3d(-42734.97852984663, -19433.99141193865, -100000.0),
Gf.Vec3d(42734.97852984663, -19433.99141193865, -100000.0),
Gf.Vec3d(-42734.97852984663, 14753.99141193864, -100000.0),
Gf.Vec3d(42734.97852984663, 14753.99141193864, -100000.0))
self._CompareFrustumCorners(gfCam.frustum.ComputeCorners(), expected)
def _getCurrentClippingRange(self):
"""Returns the current clipping range (near, far) that should be
displayed in the spin boxes.
If the view settings have values for freeCameraOverrideNear/Far, then
those values should be chosen. Otherwise, take the clipping range from
the current camera (whether a camera prim or the free camera)."""
viewSettings = self._dataModel.viewSettings
near = viewSettings.freeCameraOverrideNear
far = viewSettings.freeCameraOverrideFar
if near is not None and far is not None:
return Gf.Range1f(near, far)
cameraPrim = viewSettings.cameraPrim
if cameraPrim and cameraPrim.IsActive():
gfCam = UsdGeom.Camera(cameraPrim).GetCamera(
self._dataModel.currentFrame)
if near is None:
near = gfCam.clippingRange.min
if far is None:
far = gfCam.clippingRange.max
elif viewSettings.freeCamera:
if near is None:
near = viewSettings.freeCamera.near
if far is None:
far = viewSettings.freeCamera.far
if near is None:
near = 1.0
if far is None:
far = 1e6
return Gf.Range1f(near, far)
def _GetUsdCamera(self, cameraName):
cameraPrimPath = '/UsdExportCameraTest/Cameras/%s' % cameraName
cameraPrim = self.stage.GetPrimAtPath(cameraPrimPath)
self.assertTrue(cameraPrim)
usdCamera = UsdGeom.Camera(cameraPrim)
self.assertTrue(usdCamera)
return usdCamera
def __init__(self, appController, item):
PrimContextMenuItem.__init__(self, appController, item)
self._nonActiveCameraPrim = None
if len(self._selectionDataModel.getPrims()) == 1:
prim = self._selectionDataModel.getPrims()[0]
from pxr import UsdGeom
cam = UsdGeom.Camera(prim)
if cam:
if prim != appController.getActiveCamera():
self._nonActiveCameraPrim = prim
def test_RoundTrip(self):
baseName = 'testShotFlattened'
camPath = '/World/main_cam'
oldUsdFile, abcFile, newUsdFile = (self._RoundTripFileNames(baseName))
# USD -> ABC
self.assertTrue(UsdAbc._WriteAlembic(oldUsdFile, abcFile))
# ABC -> USD
layer = Sdf.Layer.FindOrOpen(abcFile)
self.assertTrue(layer)
self.assertTrue(layer.Export(newUsdFile))
layer = None
# Open old and new USD file on stages
oldStage = Usd.Stage.Open(oldUsdFile)
self.assertTrue(oldStage)
newStage = Usd.Stage.Open(newUsdFile)
self.assertTrue(newStage)
# Get old and new camera
oldCam = oldStage.GetPrimAtPath(camPath)
self.assertTrue(oldCam)
newCam = newStage.GetPrimAtPath(camPath)
self.assertTrue(newCam)
# Iterate through frames
for frame in range(
int(oldStage.GetStartTimeCode()),
int(oldStage.GetEndTimeCode()) + 1):
# Convert to Gf camera
oldGfCam = UsdGeom.Camera(oldCam).GetCamera(frame)
newGfCam = UsdGeom.Camera(newCam).GetCamera(frame)
# Compare frustums
self._CompareFrustumCorners(oldGfCam.frustum.ComputeCorners(),
newGfCam.frustum.ComputeCorners())
def _getCurrentFov(self):
"""Returns the current vertical field of view that should be displayed
in the spin box.
If a camera prim is active, reflect that value. Otherwise, use the
current setting."""
cameraPrim = self._dataModel.viewSettings.cameraPrim
if cameraPrim and cameraPrim.IsActive():
gfCam = UsdGeom.Camera(cameraPrim).GetCamera(
self._dataModel.currentFrame)
return gfCam.GetFieldOfView(Gf.Camera.FOVVertical)
return self._dataModel.viewSettings.freeCameraFOV
def _getCurrentAspectRatio(self):
"""Returns the current aspect ratio that should be displayed in the spin
box.
If a camera prim is active, reflect that value. Otherwise, use the
current setting."""
cameraPrim = self._dataModel.viewSettings.cameraPrim
if cameraPrim and cameraPrim.IsActive():
gfCam = UsdGeom.Camera(cameraPrim).GetCamera(
self._dataModel.currentFrame)
return gfCam.aspectRatio
return self._dataModel.viewSettings.freeCameraAspect
async def _create_kaya(self, task):
done, pending = await asyncio.wait({task})
if task in done:
print("Loading Kaya Enviornment")
# Create empty scene and camera
self._editor.set_camera_position("/OmniverseKit_Persp", -300, 300, 100, True)
self._editor.set_camera_target("/OmniverseKit_Persp", 0, 0, 0, True)
self._stage = self._usd_context.get_stage()
asset_path = "omni:/Isaac/Robots/Kaya"
kaya_usd = asset_path + "/kaya.usd"
speed_gain = 10.0
setUpZAxis(self._stage)
SetupPhysics(self._stage)
PhysicsSchemaTools.addGroundPlane(self._stage, "/physics/groundPlane", "Z", 4000, Gf.Vec3f(-100, -100, -0.001), Gf.Vec3f(0.0))
# add_ground_plane(self._stage, "/physics/ground_plane", axis='Z', size=[10000, 10000], position=[-1000, -1000, 0], color=[0, 0, 0])
# Load Kaya model
self.kaya = Kaya(
stage=self._stage, dc=self._dc, usd_path=kaya_usd, prim_path="/World/kaya", speed_gain=speed_gain
)
UsdGeom.XformCommonAPI(self.kaya.prim).SetTranslate([0, 0, 10])
# Create camera for Kaya
self.realsense_camera = self._stage.DefinePrim(f"/World/kaya/base_link/Kaya_Body/RealSense_Bridge_ASM_1/realsense/realsense_camera", "Camera")
vpi = omni.kit.viewport.get_viewport_interface()
vpi.get_viewport_window().set_active_camera(str(self.realsense_camera.GetPath()))
xform_api = UsdGeom.XformCommonAPI(self.realsense_camera)
camera_api = UsdGeom.Camera(self.realsense_camera)
camera_api.CreateFocalLengthAttr(6)
xform_api.SetRotate((0, 180, 0))
xform_api.SetTranslate((0, 5, 6))
# Load Environment
CreateBackground(
self._stage,
"omni:/Isaac/Environments/Simple_Warehouse/warehouse.usd",
# "omni:/Isaac/Environments/Grid/gridroom_curved.usd",
background_path="/World/warehouse",
offset=Gf.Vec3d(700, -3600, 0)
)
# Create cube and place
self.cube_prim = self._stage.DefinePrim(f"/World/Cube", "Cube")
# result, path = omni.kit.commands.execute("CreateShapesPrimCommand", prim_type="Cube")
# self.cube_prim = self._stage.GetPrimAtPath("/World/Cube")
UsdGeom.XformCommonAPI(self.cube_prim).SetTranslate((-100, 200, 2))
UsdGeom.XformCommonAPI(self.cube_prim).SetScale((1.5, 1.5, 1.5))
colorAttr = UsdGeom.Gprim.Get(self._stage, "/World/Cube").GetDisplayColorAttr()
colorAttr.Set([(1.0, 0.0, 0.0)])
utils.setRigidBody(self.cube_prim, "convexHull", False)
self.place_prim = self._stage.DefinePrim(f"/World/place", "Cube")
UsdGeom.XformCommonAPI(self.place_prim).SetTranslate((-400, 500, -0.95))
UsdGeom.XformCommonAPI(self.place_prim).SetScale((50, 50, 1))
colorAttr = UsdGeom.Gprim.Get(self._stage, "/World/place").GetDisplayColorAttr()
colorAttr.Set([(1.0, 0.0, 0.0)])
#
# Synthetic Data Generatorscc
self.sd = omni.syntheticdata._syntheticdata
self.sdi = self.sd.acquire_syntheticdata_interface()
# Unlock Buttons
self._train_btn.enabled = True
self._capture_btn.enabled = True
# start stepping after kaya is created
self._editor_event_subscription = self._editor.subscribe_to_update_events(self._on_editor_step)
