def test_SetFromViewAndProjectionMatrix(self):
for projection in [Gf.Camera.Perspective, Gf.Camera.Orthographic]:
cam1 = Gf.Camera()
cam1.projection = projection
cam1.focalLength = 30
cam1.horizontalAperture = 12.4
cam1.verticalAperture = 14.3
cam1.horizontalApertureOffset = 34.5
cam1.verticalApertureOffset = 25.6
cam1.clippingRange = Gf.Range1f(0.123, 345.3)
cam1.transform = (
Gf.Matrix4d().SetRotate(
Gf.Rotation(Gf.Vec3d(1,2,3), 20.3)) *
Gf.Matrix4d().SetTranslate(
Gf.Vec3d(100,123,153)))
cam2 = Gf.Camera()
cam2.SetFromViewAndProjectionMatrix(
cam1.frustum.ComputeViewMatrix(),
cam1.frustum.ComputeProjectionMatrix())
self.AssertListGfClose(cam1.frustum.ComputeCorners(),
cam2.frustum.ComputeCorners(),
delta = 1e-5)
def currentGfCamera(self):
"""A copy of the last computed Gf Camera."""
if self.__appController._stageView:
return Gf.Camera(self.__appController._stageView.gfCamera)
else:
return None
def __init__(self, isZUp):
"""FreeCamera can be either a Z up or Y up camera, based on 'zUp'"""
super(FreeCamera, self).__init__()
self._camera = Gf.Camera()
self._camera.SetPerspectiveFromAspectRatioAndFieldOfView(
1.0, 60, Gf.Camera.FOVVertical)
self._camera.clippingRange = Gf.Range1f(FreeCamera.defaultNear,
FreeCamera.defaultFar)
self._overrideNear = None
self._overrideFar = None
self._isZUp = isZUp
self._cameraTransformDirty = True
self._rotTheta = 0
self._rotPhi = 0
self._rotPsi = 0
self._center = Gf.Vec3d(0, 0, 0)
self._dist = 100
self._camera.focusDistance = self._dist
self._closestVisibleDist = None
self._lastFramedDist = None
self._lastFramedClosestDist = None
self._selSize = 10
if isZUp:
# This is also Gf.Camera.Y_UP_TO_Z_UP_MATRIX
self._YZUpMatrix = Gf.Matrix4d().SetRotate(
Gf.Rotation(Gf.Vec3d.XAxis(), -90))
self._YZUpInvMatrix = self._YZUpMatrix.GetInverse()
else:
self._YZUpMatrix = Gf.Matrix4d(1.0)
self._YZUpInvMatrix = Gf.Matrix4d(1.0)
def test_ScreenWindowParameters(self):
cam = Gf.Camera()
cam.projection = Gf.Camera.Perspective
cam.horizontalAperture = 184.5
cam.horizontalApertureOffset = 15.45
cam.verticalAperture = 20.6
cam.focalLength = 10.8
cam.transform = Gf.Matrix4d(0.890425533492, 0.433328071165,
-0.13917310100, 0.0, -0.373912364534,
0.870830610429, 0.31912942765, 0.0,
0.259483935801, -0.232122447617,
0.93743653457, 0.0, 6.533573569142,
9.880622442086, 1.89848943302, 1.0)
self._IsClose(
CameraUtil.ScreenWindowParameters(cam).screenWindow,
(-0.8325203582, 1.167479724, -0.1116531185, 0.1116531185))
self._IsClose(
CameraUtil.ScreenWindowParameters(cam).fieldOfView, 166.645202637)
self._IsClose(
CameraUtil.ScreenWindowParameters(cam).zFacingViewMatrix,
Gf.Matrix4d(0.8904255335028, -0.3739123645233, -0.259483935838, 0,
0.4333280711640, 0.8708306104262, 0.232122447596, 0,
-0.1391731009620, 0.3191294276581, -0.937436534593, 0,
-9.8349931341753, -6.7672283767831, 1.181556474823, 1))
cam.projection = Gf.Camera.Orthographic
self._IsClose(
CameraUtil.ScreenWindowParameters(cam).screenWindow,
(-7.6800003051, 10.770000457, -1.0300000190, 1.0300000190))
def test_ConformProjectionMatrix(self):
for projection in Gf.Camera.Projection.allValues:
for policy in CameraUtil.ConformWindowPolicy.allValues:
for targetAspect in [0.5, 1.0, 2.0]:
for xMirror in [-1, 1]:
for yMirror in [-1, 1]:
mirrorMatrix = Gf.Matrix4d(xMirror, 0, 0, 0, 0,
yMirror, 0, 0, 0, 0, 1,
0, 0, 0, 0, 1)
cam = Gf.Camera(projection=projection,
horizontalAperture=100.0,
verticalAperture=75.0,
horizontalApertureOffset=11.0,
verticalApertureOffset=12.0)
originalMatrix = cam.frustum.ComputeProjectionMatrix(
)
CameraUtil.ConformWindow(cam, policy, targetAspect)
self._IsClose(
cam.frustum.ComputeProjectionMatrix() *
mirrorMatrix,
CameraUtil.ConformedWindow(
originalMatrix * mirrorMatrix, policy,
targetAspect))
def test_SetFromCameraWithComposition(self):
stage = Usd.Stage.Open("layers_a_b.usda")
layerA = Sdf.Layer.FindOrOpen("a.usda")
layerB = Sdf.Layer.FindOrOpen("b.usda")
stage.SetEditTarget(layerB)
usdCamera = UsdGeom.Camera.Define(stage, '/camera')
camera = Gf.Camera()
newXform = Gf.Matrix4d().SetTranslate(Gf.Vec3d(100, 200, 300))
camera.transform = newXform
camera.horizontalAperture = 500.0
# Verify that trying to SetFromCamera from a weaker edit target does not crash,
# and does not modify any existing camera attributes.
usdCamera.SetFromCamera(camera, 1.0)
self.assertEqual(usdCamera.GetHorizontalApertureAttr().Get(1.0), 1.0)
# Now use the stronger layer
stage.SetEditTarget(layerA)
# This should succeed
usdCamera.SetFromCamera(camera, 1.0)
self.assertEqual(usdCamera.GetHorizontalApertureAttr().Get(1.0), 500.0)
self.assertEqual(usdCamera.ComputeLocalToWorldTransform(1.0), newXform)
def export_gf(self, tile=((0.0, 0.0), (1.0, 1.0))):
tile_pos, tile_size = tile
gf_camera = Gf.Camera()
gf_camera.clippingRange = Gf.Range1f(*self.clip_plane)
# following formula is used:
# lens_shift = lens_shift * resolution / tile_size + (center - resolution/2) / tile_size
# where: center = tile_pos + tile_size/2
lens_shift = tuple(
(self.lens_shift[i] + tile_pos[i] + tile_size[i] * 0.5 - 0.5) /
tile_size[i] for i in (0, 1))
# usd_camera.set_lens_shift(*lens_shift)
gf_camera.horizontalApertureOffset = lens_shift[0]
gf_camera.verticalApertureOffset = lens_shift[1]
if self.mode == 'PERSP':
gf_camera.projection = Gf.Camera.Perspective
gf_camera.focalLength = self.focal_length
sensor_size = tuple(self.sensor_size[i] * tile_size[i]
for i in (0, 1))
gf_camera.horizontalAperture = sensor_size[0]
gf_camera.verticalAperture = sensor_size[1]
gf_camera.focalLength = self.focal_length
elif self.mode == 'ORTHO':
gf_camera.projection = Gf.Camera.Orthographic
# Use tenths of a world unit
ortho_size = tuple(self.ortho_size[i] * tile_size[i] * 10
for i in (0, 1))
log(f"export_gf ortho_size: {ortho_size}")
gf_camera.horizontalAperture = ortho_size[0]
gf_camera.verticalAperture = ortho_size[1]
elif self.mode == 'PANO':
# TODO: store panoramic camera settings
pass
# usd_camera.set_sensor_size(*self.sensor_size)
# usd_camera.set_focal_length(self.focal_length)
if self.dof_data:
# TODO: store Depth Of Field camera settings
pass
# usd_camera.set_focus_distance(self.dof_data[0])
# usd_camera.set_f_stop(self.dof_data[1])
# usd_camera.set_aperture_blades(self.dof_data[2])
else:
pass
# usd_camera.set_f_stop(None)
gf_camera.transform = Gf.Matrix4d(np.transpose(self.transform))
return gf_camera
def testUsdviewInputFunction(appController):
_modifySettings(appController)
start = _GetFreeCamera(appController)
startGfCam, startIsZUp = Gf.Camera(start._camera), start._isZUp
_takeShot(appController, "start.png")
_testFreeCameraTumble(appController)
_SetFreeCamera(appController, startGfCam, startIsZUp)
_testFreeCameraAdjustDistance(appController)
_SetFreeCamera(appController, startGfCam, startIsZUp)
_testFreeCameraTruck(appController)
_SetFreeCamera(appController, startGfCam, startIsZUp)
_takeShot(appController, "end.png")
def test_SetFromCamera(self):
camera = Gf.Camera()
usdStage = Usd.Stage.CreateInMemory()
usdCamera = UsdGeom.Camera.Define(usdStage, '/camera')
usdCameraProj = usdCamera.GetProjectionAttr()
# test fall-back values
self._CheckValues(camera, usdCamera, 1.0)
self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
Usd.ResolveInfoSourceFallback)
camera.transform = (
Gf.Matrix4d().SetRotate(Gf.Rotation(Gf.Vec3d(1.0, 2.0, 3.0), 10.0))
* Gf.Matrix4d().SetTranslate(Gf.Vec3d(4.0, 5.0, 6.0)))
camera.projection = Gf.Camera.Orthographic
camera.horizontalAperture = 5.1
camera.verticalAperture = 2.0
camera.horizontalApertureOffset = 0.13
camera.verticalApertureOffset = -0.14
camera.focalLength = 28
camera.clippingRange = Gf.Range1f(5, 15)
camera.clippingPlanes = [[1, 2, 3, 4], [8, 7, 6, 5]]
camera.fStop = 1.2
camera.focusDistance = 300
usdCamera.SetFromCamera(camera, 1.0)
# test assigned values
self._CheckValues(camera, usdCamera, 1.0)
self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
Usd.ResolveInfoSourceTimeSamples)
usdCamera.SetFromCamera(camera, 1.0)
actual = usdCamera.GetLocalTransformation(Usd.TimeCode(1.0))
expected = Gf.Matrix4d(0.9858929135, 0.14139860385, -0.089563373740,
0.0, -0.1370579618, 0.98914839500,
0.052920390613, 0.0, 0.0960743367,
-0.03989846462, 0.994574197504, 0.0, 4.0, 5.0,
6.0, 1.0)
for a, e in zip(actual, expected):
self.assertTrue(Gf.IsClose(a, e, 1e-2))
def clone(self):
clone = FreeCamera(self._isZUp)
clone._camera = Gf.Camera(self._camera)
# skipping stereo attrs for now
clone._rotTheta = self._rotTheta
clone._rotPhi = self._rotPhi
clone._rotPsi = self._rotPsi
clone._center = Gf.Vec3d(self._center)
clone._dist = self._dist
clone._closestVisibleDist = self._closestVisibleDist
clone._lastFramedClosestDist = self._lastFramedClosestDist
clone._lastFramedDist = self._lastFramedDist
clone._selSize = self._selSize
clone._overrideNear = self._overrideNear
clone._overrideFar = self._overrideFar
clone._YZUpMatrix = Gf.Matrix4d(self._YZUpMatrix)
clone._YZUpInvMatrix = Gf.Matrix4d(self._YZUpInvMatrix)
return clone
def test_ConformWindow(self):
cam = Gf.Camera()
cam.horizontalAperture = 100.0
cam.verticalAperture = 75.0
cam.horizontalApertureOffset = 11.0
cam.verticalApertureOffset = 12.0
CameraUtil.ConformWindow(camera=cam,
policy=CameraUtil.Fit,
targetAspect=2.0)
self._IsClose(cam.horizontalAperture, 150.0)
self._IsClose(cam.verticalAperture, 75.0)
self._IsClose(cam.horizontalApertureOffset, 11.0)
self._IsClose(cam.verticalApertureOffset, 12.0)
CameraUtil.ConformWindow(cam, CameraUtil.Fit, 1.5)
self._IsClose(cam.horizontalAperture, 150.0)
self._IsClose(cam.verticalAperture, 100.0)
self._IsClose(cam.horizontalApertureOffset, 11.0)
self._IsClose(cam.verticalApertureOffset, 12.0)
def test_GetCamera(self):
usdStage = Usd.Stage.CreateInMemory()
usdCamera = UsdGeom.Camera.Define(usdStage, '/camera')
# test fall-back values
self._CheckValues(Gf.Camera(), usdCamera, 1.0)
usdCamera.MakeMatrixXform().Set(Gf.Matrix4d(3.0))
usdCamera.GetProjectionAttr().Set(UsdGeom.Tokens.orthographic)
usdCamera.GetHorizontalApertureAttr().Set(5.1)
usdCamera.GetVerticalApertureAttr().Set(2.0)
usdCamera.GetHorizontalApertureOffsetAttr().Set(-0.11)
usdCamera.GetVerticalApertureOffsetAttr().Set(0.12)
usdCamera.GetFocalLengthAttr().Set(28)
usdCamera.GetClippingRangeAttr().Set(Gf.Vec2f(5, 15))
usdCamera.GetClippingPlanesAttr().Set([(1,2,3,4), (8,7,6,5)])
usdCamera.GetFStopAttr().Set(1.2)
usdCamera.GetFocusDistanceAttr().Set(300)
camera = usdCamera.GetCamera(1.0)
# test assigned values
self._CheckValues(camera, usdCamera, 1.0)
def test_CameraEqualOperator(self):
cam1 = Gf.Camera()
cam2 = Gf.Camera()
self.assertTrue(cam1 == cam2)
cam1.transform = Gf.Matrix4d(1.0).SetTranslate(Gf.Vec3d(10,20,30))
self.assertFalse(cam1 == cam2)
self.assertTrue(cam1 != cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.horizontalAperture = 100
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.verticalAperture = 200
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.horizontalApertureOffset = 10
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.verticalApertureOffset = 20
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.focalLength = 45
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.clippingRange = Gf.Range1f(3,30)
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.clippingPlanes = [
Gf.Vec4f(0.32929277420043, 0.5488212704658, 0.768349826335, 10.0),
Gf.Vec4f(0.68100523948669, 0.4256282746791, 0.595879554748, 20.0)
]
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.fStop = 11
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
cam1.focusDistance = 102
self.assertFalse(cam1 == cam2)
cam2 = Gf.Camera(cam1)
self.assertTrue(cam1 == cam2)
self.AssertCamSelfEvaluating(cam1)
def TestCameraOrthonormal(self):
cam = Gf.Camera()
self.AssertCamSelfEvaluating(cam)
transform = (
Gf.Matrix4d().SetRotate(
Gf.Rotation(Gf.Vec3d(1,-2,3), 30.3)) *
Gf.Matrix4d().SetTranslate(
Gf.Vec3d(-100,123,153)))
cam.transform = transform
self.AssertCamSelfEvaluating(cam)
cam.horizontalAperture = 34 / 2
self.assertAlmostEqual(cam.horizontalAperture, 34 / 2)
cam.verticalAperture = 20
self.assertAlmostEqual(cam.verticalAperture, 20)
self.AssertCamSelfEvaluating(cam)
cam.horizontalAperture *= 2
self.AssertCamSelfEvaluating(cam)
cam.focalLength = 50
self.assertAlmostEqual(cam.focalLength, 50)
self.AssertCamSelfEvaluating(cam)
self.assertAlmostEqual(cam.GetFieldOfView(Gf.Camera.FOVHorizontal),
37.556064606)
self.assertAlmostEqual(cam.horizontalFieldOfView, 37.556064606)
self.assertAlmostEqual(cam.GetFieldOfView(Gf.Camera.FOVVertical),
22.619864948)
self.assertAlmostEqual(cam.verticalFieldOfView, 22.619864948)
cam.projection = Gf.Camera.Orthographic
self.AssertCamSelfEvaluating(cam)
cam.SetPerspectiveFromAspectRatioAndFieldOfView(
aspectRatio = 1.7,
fieldOfView = 65.0,
direction = Gf.Camera.FOVHorizontal,
horizontalAperture = 34.0)
self.AssertCamSelfEvaluating(cam)
otherCam = Gf.Camera(
transform = Gf.Matrix4d(
0.8731530112777166, 0.3850071166178898, 0.2989537406526877, 0,
-0.4240369593016693, 0.9024253932905512, 0.07629591529425725, 0,
-0.2404089766270184, -0.1933854433455958, 0.9512126966452756, 0,
-100.0, 123.0, 153.0, 1.0),
projection = Gf.Camera.Perspective,
horizontalAperture = 34.0,
verticalAperture = 20.0,
focalLength = 26.684656143188477)
self.AssertEqualCams(cam, otherCam)
self.assertEqual(cam.projection, Gf.Camera.Perspective)
# Field of view is achieved by setting new focal
# length
self.assertAlmostEqual(cam.focalLength, 26.6846561432)
self.assertAlmostEqual(cam.horizontalAperture, 34)
cam.clippingRange = Gf.Range1f(10, 100)
self.assertAlmostEqual(cam.clippingRange, Gf.Range1f(10, 100))
self.assertAlmostEqual(cam.aspectRatio, 34.0/20.0)
cam.SetPerspectiveFromAspectRatioAndFieldOfView(
aspectRatio = 2.4,
fieldOfView = 29.7321955,
direction = Gf.Camera.FOVVertical,
horizontalAperture = 34.0)
self.assertAlmostEqual(cam.aspectRatio, 2.4)
self.assertAlmostEqual(cam.verticalAperture, 34.0/2.4)
self.assertAlmostEqual(cam.focalLength, 26.6846561432)
# We have setup focal length, horizontal and vertical
# aperture. We are now in a position to test the frustum
# We test this with perspective first.
cam.projection = Gf.Camera.Perspective
self.assertEqual(cam.projection, Gf.Camera.Perspective)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(-102.032919327869, 120.085637354940, 141.38080336149),
Gf.Vec3d(-90.9077235508873, 124.991168793969, 145.18989392187),
Gf.Vec3d(-104.284096916572, 124.876540072942, 141.78585214522),
Gf.Vec3d(-93.1589011395900, 129.782071511971, 145.59494270559),
Gf.Vec3d(-120.329193278696, 93.8563735494037, 36.808033614959),
Gf.Vec3d(-9.07723550887376, 142.911687939691, 74.898939218725),
Gf.Vec3d(-142.840969165722, 141.765400729428, 40.858521452219),
Gf.Vec3d(-31.5890113959001, 190.820715119715, 78.949427055984)))
cam.horizontalAperture = 340
self.assertAlmostEqual(cam.horizontalAperture, 340)
cam.verticalAperture = 340 / 2.4
self.assertAlmostEqual(cam.aspectRatio, 2.4)
cam.projection = Gf.Camera.Orthographic
self.assertEqual(cam.projection, Gf.Camera.Orthographic)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(-109.435916189226, 111.996553352311, 137.8652300230474),
Gf.Vec3d( -79.748713805783, 125.086795317320, 148.0296572052388),
Gf.Vec3d(-115.443106661676, 124.780913549591, 138.9460888618555),
Gf.Vec3d( -85.755904278233, 137.871155514600, 149.1105160440469),
Gf.Vec3d( -87.799108292794, 129.401243253415, 52.2560873249726),
Gf.Vec3d( -58.111905909352, 142.491485218423, 62.4205145071640),
Gf.Vec3d( -93.806298765244, 142.185603450695, 53.3369461637807),
Gf.Vec3d( -64.119096381802, 155.275845415703, 63.5013733459721)))
cam = Gf.Camera()
cam.SetOrthographicFromAspectRatioAndSize(
2.4, 34.0,
direction = Gf.Camera.FOVHorizontal)
cam.transform = transform
cam.clippingRange = Gf.Range1f(10, 100)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(-109.43591651274, 111.9965540408077, 137.8652300812566),
Gf.Vec3d( -79.74871412929, 125.0867960058159, 148.0296572634480),
Gf.Vec3d(-115.44310633816, 124.7809128610959, 138.9460888036464),
Gf.Vec3d( -85.75590395471, 137.8711548261041, 149.1105159858378),
Gf.Vec3d( -87.79910861630, 129.4012439419113, 52.2560873831818),
Gf.Vec3d( -58.11190623286, 142.4914859069195, 62.4205145653732),
Gf.Vec3d( -93.80629844172, 142.1856027621995, 53.3369461055715),
Gf.Vec3d( -64.11909605828, 155.2758447272077, 63.5013732877629)))
cam = Gf.Camera()
cam.SetOrthographicFromAspectRatioAndSize(
2.4, 34.0 / 2.4,
direction = Gf.Camera.FOVVertical)
cam.transform = transform
cam.clippingRange = Gf.Range1f(10, 100)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(-109.435917521551, 111.996552764837, 137.8652295668803),
Gf.Vec3d( -79.748712473457, 125.086795904794, 148.0296576614060),
Gf.Vec3d(-115.443107994001, 124.780912962117, 138.9460884056883),
Gf.Vec3d( -85.755902945907, 137.871156102074, 149.1105165002141),
Gf.Vec3d( -87.799109625120, 129.401242665941, 52.2560868688054),
Gf.Vec3d( -58.111904577026, 142.491485805897, 62.4205149633312),
Gf.Vec3d( -93.806300097570, 142.185602863221, 53.3369457076135),
Gf.Vec3d( -64.119095049476, 155.275846003177, 63.5013738021393)),
epsilon = 1e-4)
self.assertAlmostEqual(
Gf.Camera(cam).frustum.ComputeCorners(),
(Gf.Vec3d(-109.435917521551, 111.996552764837, 137.8652295668803),
Gf.Vec3d( -79.748712473457, 125.086795904794, 148.0296576614060),
Gf.Vec3d(-115.443107994001, 124.780912962117, 138.9460884056883),
Gf.Vec3d( -85.755902945907, 137.871156102074, 149.1105165002141),
Gf.Vec3d( -87.799109625120, 129.401242665941, 52.2560868688054),
Gf.Vec3d( -58.111904577026, 142.491485805897, 62.4205149633312),
Gf.Vec3d( -93.806300097570, 142.185602863221, 53.3369457076135),
Gf.Vec3d( -64.119095049476, 155.275846003177, 63.5013738021393)),
epsilon = 1e-4)
transform = (
Gf.Matrix4d().SetRotate(
Gf.Rotation(Gf.Vec3d(2,3,4), 14.2)) *
Gf.Matrix4d().SetTranslate(
Gf.Vec3d(99.0, 111.0, 134.0)))
cam = Gf.Camera()
cam.SetPerspectiveFromAspectRatioAndFieldOfView(
aspectRatio = 2.4,
fieldOfView = 29.7321955,
direction = Gf.Camera.FOVVertical,
horizontalAperture = 34.0)
cam.clippingRange = Gf.Range1f(10, 100)
cam = Gf.Camera()
cam.projection = Gf.Camera.Perspective
cam.focalLength = 50
cam.verticalApertureOffset = 1.2
self.assertAlmostEqual(
Gf.Camera(cam).frustum.ComputeCorners(),
(Gf.Vec3d(-0.20954999923706, -0.128907999992370, -1.0),
Gf.Vec3d(0.209549999237060, -0.128907999992370, -1.0),
Gf.Vec3d(-0.20954999923706, 0.1769080018997192, -1.0),
Gf.Vec3d(0.209549999237060, 0.1769080018997192, -1.0),
Gf.Vec3d(-209549.999237060, -128907.9999923706, -1000000.0),
Gf.Vec3d(209549.9992370605, -128907.9999923706, -1000000.0),
Gf.Vec3d(-209549.999237060, 176908.00189971924, -1000000.0),
Gf.Vec3d(209549.9992370605, 176908.00189971924, -1000000.0)),
delta = 1e-4)
cam.focusDistance = 200
cam.fStop = 11
self.assertAlmostEqual(cam.focusDistance, 200)
self.assertAlmostEqual(cam.fStop, 11)
self.AssertCamSelfEvaluating(cam)
def TestCameraNonOrthonormal(self):
cam = Gf.Camera()
transform = (
Gf.Matrix4d().SetRotate(
Gf.Rotation(Gf.Vec3d(1,2,3), 20.3)) *
Gf.Matrix4d().SetTranslate(
Gf.Vec3d(100,123,153)) *
Gf.Matrix4d().SetScale(
Gf.Vec3d(2.0,1.0,1.3)))
cam.transform = transform
self.assertAlmostEqual(cam.transform, transform)
cam.horizontalAperture = 34 / 2
self.assertAlmostEqual(cam.horizontalAperture, 34 / 2)
cam.verticalAperture = 20
self.assertAlmostEqual(cam.verticalAperture, 20)
cam.horizontalAperture *= 2
cam.focalLength = 50
self.assertAlmostEqual(cam.focalLength, 50)
self.assertAlmostEqual(cam.GetFieldOfView(Gf.Camera.FOVHorizontal),
37.556064606)
self.assertAlmostEqual(cam.horizontalFieldOfView, 37.556064606)
self.assertAlmostEqual(cam.GetFieldOfView(Gf.Camera.FOVVertical),
22.619864948)
self.assertAlmostEqual(cam.verticalFieldOfView, 22.619864948)
cam.projection = Gf.Camera.Orthographic
cam.SetPerspectiveFromAspectRatioAndFieldOfView(
aspectRatio = 1.7,
fieldOfView = 65.0,
direction = Gf.Camera.FOVHorizontal,
horizontalAperture = 34.0)
self.assertEqual(cam.projection, Gf.Camera.Perspective)
# Field of view is achieved by setting new focal
# length
self.assertAlmostEqual(cam.focalLength, 26.6846561432)
self.assertAlmostEqual(cam.horizontalAperture, 34)
cam.clippingRange = Gf.Range1f(10, 100)
self.assertAlmostEqual(cam.clippingRange, Gf.Range1f(10, 100))
self.assertAlmostEqual(cam.aspectRatio, 34.0/20.0)
cam.SetPerspectiveFromAspectRatioAndFieldOfView(
aspectRatio = 2.4,
fieldOfView = 29.7321955,
direction = Gf.Camera.FOVVertical,
horizontalAperture = 34.0)
self.assertAlmostEqual(cam.aspectRatio, 2.4)
self.assertAlmostEqual(cam.verticalAperture, 34.0/2.4)
self.assertAlmostEqual(cam.focalLength, 26.6846561432)
# We have setup focal length, horizontal and vertical
# aperture. We are now in a position to test the frustum
# We test this with perspective first.
cam.projection = Gf.Camera.Perspective
self.assertEqual(cam.projection, Gf.Camera.Perspective)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(192.846230529544, 118.9700660570964, 189.943705234630),
Gf.Vec3d(204.624699588231, 123.2629367321672, 187.667234572988),
Gf.Vec3d(191.159053763979, 123.9580649710064, 190.620399628732),
Gf.Vec3d(202.937522822666, 128.2509356460773, 188.343928967090),
Gf.Vec3d(128.462305295447, 82.70066057096416, 109.337052346305),
Gf.Vec3d(246.246995882312, 125.6293673216727, 86.5723457298875),
Gf.Vec3d(111.590537639799, 132.5806497100646, 116.103996287320),
Gf.Vec3d(229.375228226663, 175.5093564607731, 93.3392896709023)))
cam.horizontalAperture = 340
self.assertAlmostEqual(cam.horizontalAperture, 340)
cam.verticalAperture = 340 / 2.4
self.assertAlmostEqual(cam.aspectRatio, 2.4)
cam.projection = Gf.Camera.Orthographic
self.assertEqual(cam.projection, Gf.Camera.Orthographic)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(184.427743371372, 111.227660346205, 191.278291105439),
Gf.Vec3d(215.858183043795, 122.683038129349, 185.203607422842),
Gf.Vec3d(179.925570308415, 124.537963573823, 193.084026778878),
Gf.Vec3d(211.356009980839, 135.993341356968, 187.009343096281),
Gf.Vec3d(165.454633456322, 116.722168010487, 103.472645013183),
Gf.Vec3d(196.885073128745, 128.177545793631, 97.3979613305862),
Gf.Vec3d(160.952460393365, 130.032471238105, 105.278380686621),
Gf.Vec3d(192.382900065789, 141.487849021250, 99.2036970040248)))
cam = Gf.Camera()
cam.SetOrthographicFromAspectRatioAndSize(
2.4, 34.0,
direction = Gf.Camera.FOVHorizontal)
cam.transform = transform
cam.clippingRange = Gf.Range1f(10, 100)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(184.427743371372, 111.227660346205, 191.278291105439),
Gf.Vec3d(215.858183043795, 122.683038129349, 185.203607422842),
Gf.Vec3d(179.925570308415, 124.537963573823, 193.084026778878),
Gf.Vec3d(211.356009980839, 135.993341356968, 187.009343096281),
Gf.Vec3d(165.454633456322, 116.722168010487, 103.472645013183),
Gf.Vec3d(196.885073128745, 128.177545793631, 97.3979613305862),
Gf.Vec3d(160.952460393365, 130.032471238105, 105.278380686621),
Gf.Vec3d(192.382900065789, 141.487849021250, 99.2036970040248)))
cam = Gf.Camera()
cam.SetOrthographicFromAspectRatioAndSize(
2.4, 34.0 / 2.4,
direction = Gf.Camera.FOVVertical)
cam.transform = transform
cam.clippingRange = Gf.Range1f(10, 100)
self.assertAlmostEqual(
cam.frustum.ComputeCorners(),
(Gf.Vec3d(184.427743371372, 111.227660346205, 191.278291105439),
Gf.Vec3d(215.858183043795, 122.683038129349, 185.203607422842),
Gf.Vec3d(179.925570308415, 124.537963573823, 193.084026778878),
Gf.Vec3d(211.356009980839, 135.993341356968, 187.009343096281),
Gf.Vec3d(165.454633456322, 116.722168010487, 103.472645013183),
Gf.Vec3d(196.885073128745, 128.177545793631, 97.3979613305862),
Gf.Vec3d(160.952460393365, 130.032471238105, 105.278380686621),
Gf.Vec3d(192.382900065789, 141.487849021250, 99.2036970040248)),
epsilon = 1e-4)
transform = (
Gf.Matrix4d().SetRotate(
Gf.Rotation(Gf.Vec3d(2,3,4), 14.2)) *
Gf.Matrix4d().SetTranslate(
Gf.Vec3d(99.0, 111.0, 134.0)))
cam = Gf.Camera()
cam.SetPerspectiveFromAspectRatioAndFieldOfView(
aspectRatio = 2.4,
fieldOfView = 29.7321955,
direction = Gf.Camera.FOVVertical,
horizontalAperture = 34.0)
cam.clippingRange = Gf.Range1f(10, 100)
clippingPlanes = [
Gf.Vec4f(0.32929277420043, 0.5488212704658, 0.768349826335, 10.0),
Gf.Vec4f(0.68100523948669, 0.4256282746791, 0.595879554748, 20.0)
]
cam.clippingPlanes = clippingPlanes
self.assertAlmostEqual(cam.clippingPlanes, clippingPlanes)
self.AssertCamSelfEvaluating(cam)
