def test_Str(self):
f = Gf.Frustum()
f.projectionType = f.Perspective
self.assertTrue(len(str(f)))
f.projectionType = f.Orthographic
self.assertTrue(len(str(f)))
def test_PrimvarsAPI(self):
IsPrimvar = UsdGeom.Primvar.IsPrimvar
# We'll put all our Primvar on a single mesh gprim
stage = Usd.Stage.CreateInMemory('myTest.usda')
gp = UsdGeom.Mesh.Define(stage, '/myMesh')
gp_pv = UsdGeom.PrimvarsAPI(gp)
nPasses = 3
# Add three Primvars
u1 = gp_pv.CreatePrimvar('u_1', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(u1.NameContainsNamespaces())
# Make sure it's OK to manually specify the classifier namespace
v1 = gp_pv.CreatePrimvar('primvars:v_1', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(v1.NameContainsNamespaces())
_3dpmats = gp_pv.CreatePrimvar('projMats',
Sdf.ValueTypeNames.Matrix4dArray,
"constant", nPasses)
# ensure we can create a primvar that contains namespaces!
primvarName = 'skel:jointWeights'
jointWeights = gp_pv.CreatePrimvar(primvarName,
Sdf.ValueTypeNames.FloatArray)
self.assertTrue(IsPrimvar(jointWeights))
self.assertTrue(jointWeights.NameContainsNamespaces())
self.assertEqual(primvarName, jointWeights.GetPrimvarName())
# Ensure we cannot create a primvar named indices or any namespace
# ending in indices
with self.assertRaises(Tf.ErrorException):
gp_pv.CreatePrimvar("indices", Sdf.ValueTypeNames.IntArray)
with self.assertRaises(Tf.ErrorException):
gp_pv.CreatePrimvar("multi:aggregate:indices",
Sdf.ValueTypeNames.IntArray)
self.assertEqual(len(gp_pv.GetAuthoredPrimvars()), 4)
# displayColor and displayOpacity are builtins, not authored
self.assertEqual(len(gp_pv.GetPrimvars()), 6)
# Now add some random properties, plus a "manually" created, namespaced
# primvar, and reverify
p = gp.GetPrim()
p.CreateRelationship("myBinding")
p.CreateAttribute("myColor", Sdf.ValueTypeNames.Color3f)
p.CreateAttribute("primvars:some:overly:namespaced:Color",
Sdf.ValueTypeNames.Color3f)
datas = gp_pv.GetAuthoredPrimvars()
self.assertEqual(len(datas), 5)
self.assertTrue(IsPrimvar(datas[0]))
self.assertTrue(IsPrimvar(datas[1]))
# For variety, test the explicit Attribute extractor
self.assertTrue(IsPrimvar(datas[2].GetAttr()))
self.assertFalse(IsPrimvar(p.GetAttribute("myColor")))
# Here we're testing that the speculative constructor fails properly
self.assertFalse(IsPrimvar(UsdGeom.Primvar(p.GetAttribute("myColor"))))
# And here that the speculative constructor succeeds properly
self.assertTrue(
IsPrimvar(UsdGeom.Primvar(p.GetAttribute(v1.GetName()))))
# Some of the same tests, exercising the bool-type operator
# for UsdGeomPrimvar; Primvar provides the easiest way to get INvalid attrs!
self.assertTrue(datas[0])
self.assertTrue(datas[1])
self.assertTrue(datas[2])
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myColor")))
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myBinding")))
self.assertTrue(UsdGeom.Primvar(p.GetAttribute(v1.GetName())))
# Same classification test through GprimSchema API
self.assertTrue(gp_pv.HasPrimvar('u_1'))
self.assertTrue(gp_pv.HasPrimvar('v_1'))
self.assertTrue(gp_pv.HasPrimvar('projMats'))
self.assertTrue(gp_pv.HasPrimvar('skel:jointWeights'))
self.assertFalse(gp_pv.HasPrimvar('myColor'))
self.assertFalse(gp_pv.HasPrimvar('myBinding'))
# Test that the gpv's returned by GetPrimvars are REALLY valid,
# and that the UsdAttribute metadata wrappers work
self.assertEqual(datas[0].GetTypeName(),
Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(datas[3].GetTypeName(), Sdf.ValueTypeNames.FloatArray)
self.assertEqual(datas[4].GetBaseName(), "v_1")
# Now we'll add some extra configuration and verify that the
# interrogative API works properly
self.assertEqual(u1.GetInterpolation(),
UsdGeom.Tokens.constant) # fallback
self.assertFalse(u1.HasAuthoredInterpolation())
self.assertFalse(u1.HasAuthoredElementSize())
self.assertTrue(u1.SetInterpolation(UsdGeom.Tokens.vertex))
self.assertTrue(u1.HasAuthoredInterpolation())
self.assertEqual(u1.GetInterpolation(), UsdGeom.Tokens.vertex)
self.assertFalse(v1.HasAuthoredInterpolation())
self.assertFalse(v1.HasAuthoredElementSize())
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.uniform))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.varying))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.constant))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.faceVarying))
with self.assertRaises(Tf.ErrorException):
v1.SetInterpolation("frobosity")
# Should be the last good value set
self.assertEqual(v1.GetInterpolation(), "faceVarying")
self.assertTrue(_3dpmats.HasAuthoredInterpolation())
self.assertTrue(_3dpmats.HasAuthoredElementSize())
with self.assertRaises(Tf.ErrorException):
_3dpmats.SetElementSize(0)
# Failure to set shouldn't change the state...
self.assertTrue(_3dpmats.HasAuthoredElementSize())
self.assertTrue(_3dpmats.SetElementSize(nPasses))
self.assertTrue(_3dpmats.HasAuthoredElementSize())
# Make sure value Get/Set work
self.assertEqual(u1.Get(), None)
self.assertFalse(u1.IsIndexed())
self.assertFalse(u1.GetIndicesAttr())
self.assertEqual(u1.ComputeFlattened(), None)
uVal = Vt.FloatArray([1.1, 2.1, 3.1])
self.assertTrue(u1.Set(uVal))
self.assertEqual(u1.Get(), uVal)
# Make sure indexed primvars work
self.assertFalse(u1.IsIndexed())
indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
self.assertTrue(u1.SetIndices(indices))
self.assertTrue(u1.IsIndexed())
self.assertTrue(u1.GetIndicesAttr())
self.assertEqual(u1.GetIndices(), indices)
for a, b in zip(u1.ComputeFlattened(), [1.1, 2.1, 3.1, 3.1, 2.1, 1.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(), u1.Get())
indicesWithInvalid = Vt.IntArray([0, 3, 2, 2, -1, 0])
self.assertTrue(u1.SetIndices(indicesWithInvalid))
self.assertTrue(u1.ComputeFlattened() is None)
indicesWithInvalid = Vt.IntArray([4, 5, 6, 7, -1, 8])
self.assertTrue(u1.SetIndices(indicesWithInvalid))
self.assertTrue(u1.ComputeFlattened() is None)
self.assertEqual(u1.GetUnauthoredValuesIndex(), -1)
self.assertTrue(u1.SetUnauthoredValuesIndex(2))
self.assertEqual(u1.GetUnauthoredValuesIndex(), 2)
self.assertEqual(u1.GetTimeSamples(), [])
self.assertFalse(u1.ValueMightBeTimeVarying())
indicesAt1 = Vt.IntArray([1, 2, 0])
indicesAt2 = Vt.IntArray([])
uValAt1 = Vt.FloatArray([2.1, 3.1, 4.1])
uValAt2 = Vt.FloatArray([3.1, 4.1, 5.1])
self.assertTrue(u1.SetIndices(indicesAt1, 1.0))
self.assertEqual(u1.GetIndices(1.0), indicesAt1)
self.assertTrue(u1.Set(uValAt1, 1.0))
self.assertEqual(u1.Get(1.0), uValAt1)
self.assertEqual(u1.GetTimeSamples(), [1.0])
self.assertFalse(u1.ValueMightBeTimeVarying())
self.assertTrue(u1.SetIndices(indicesAt2, 2.0))
self.assertEqual(u1.GetIndices(2.0), indicesAt2)
self.assertTrue(u1.Set(uValAt2, 2.0))
self.assertEqual(u1.Get(2.0), uValAt2)
self.assertEqual(u1.GetTimeSamples(), [1.0, 2.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(0.5, 1.5)),
[1.0])
self.assertTrue(u1.ValueMightBeTimeVarying())
# Add more time-samples to u1
indicesAt0 = Vt.IntArray([])
uValAt3 = Vt.FloatArray([4.1, 5.1, 6.1])
self.assertTrue(u1.SetIndices(indicesAt0, 0.0))
self.assertEqual(u1.GetTimeSamples(), [0.0, 1.0, 2.0])
self.assertTrue(u1.Set(uValAt3, 3.0))
self.assertEqual(u1.GetTimeSamples(), [0.0, 1.0, 2.0, 3.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(1.5, 3.5)),
[2.0, 3.0])
for a, b in zip(u1.ComputeFlattened(1.0), [3.1, 4.1, 2.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(1.0), u1.Get(1.0))
self.assertTrue(len(u1.ComputeFlattened(2.0)) == 0)
self.assertNotEqual(u1.ComputeFlattened(2.0), u1.Get(2.0))
# Ensure that primvars with indices only authored at timeSamples
# (i.e. no default) are recognized as such. Manual name-munging
# necessitated by UsdGeomPrimvar's lack of API for accessing
# the indices attribute directly!
u1Indices = p.GetAttribute(u1.GetName() + ":indices")
self.assertTrue(u1Indices)
u1Indices.ClearDefault()
self.assertTrue(u1.IsIndexed())
# Finally, ensure the values returned by GetDeclarationInfo
# (on new Primvar objects, to test the GprimSchema API)
# is identical to the individual queries, and matches what we set above
nu1 = gp_pv.GetPrimvar("u_1")
(name, typeName, interpolation, elementSize) = nu1.GetDeclarationInfo()
self.assertEqual(name, u1.GetBaseName())
self.assertEqual(typeName, u1.GetTypeName())
self.assertEqual(interpolation, u1.GetInterpolation())
self.assertEqual(elementSize, u1.GetElementSize())
self.assertEqual(name, "u_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.vertex)
self.assertEqual(elementSize, 1)
nv1 = gp_pv.GetPrimvar("v_1")
(name, typeName, interpolation, elementSize) = nv1.GetDeclarationInfo()
self.assertEqual(name, v1.GetBaseName())
self.assertEqual(typeName, v1.GetTypeName())
self.assertEqual(interpolation, v1.GetInterpolation())
self.assertEqual(elementSize, v1.GetElementSize())
self.assertEqual(name, "v_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.faceVarying)
self.assertEqual(elementSize, 1)
nmats = gp_pv.GetPrimvar('projMats')
(name, typeName, interpolation,
elementSize) = nmats.GetDeclarationInfo()
self.assertEqual(name, _3dpmats.GetBaseName())
self.assertEqual(typeName, _3dpmats.GetTypeName())
self.assertEqual(interpolation, _3dpmats.GetInterpolation())
self.assertEqual(elementSize, _3dpmats.GetElementSize())
self.assertEqual(name, 'projMats')
self.assertEqual(typeName, Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(interpolation, UsdGeom.Tokens.constant)
self.assertEqual(elementSize, nPasses)
# Custom builtins for gprim display primvars
displayColor = gp.CreateDisplayColorPrimvar(UsdGeom.Tokens.vertex, 3)
self.assertTrue(displayColor)
declInfo = displayColor.GetDeclarationInfo()
self.assertEqual(declInfo,
('displayColor', Sdf.ValueTypeNames.Color3fArray,
UsdGeom.Tokens.vertex, 3))
displayOpacity = gp.CreateDisplayOpacityPrimvar(
UsdGeom.Tokens.constant)
self.assertTrue(displayOpacity)
declInfo = displayOpacity.GetDeclarationInfo()
self.assertEqual(declInfo,
('displayOpacity', Sdf.ValueTypeNames.FloatArray,
UsdGeom.Tokens.constant, 1))
# Id primvar
notId = gp_pv.CreatePrimvar('notId', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(notId.IsIdTarget())
with self.assertRaises(Tf.ErrorException):
notId.SetIdTarget(gp.GetPath())
handleid = gp_pv.CreatePrimvar('handleid', Sdf.ValueTypeNames.String)
# make sure we can still just set a string
v = "handleid_value"
self.assertTrue(handleid.Set(v))
self.assertEqual(handleid.Get(), v)
self.assertEqual(handleid.ComputeFlattened(), v)
numPrimvars = len(gp_pv.GetPrimvars())
# This check below ensures that the "indices" attributes belonging to
# indexed primvars aren't considered to be primvars themselves.
self.assertEqual(numPrimvars, 9)
self.assertTrue(handleid.SetIdTarget(gp.GetPath()))
# make sure we didn't increase the number of primvars (also that
# GetPrimvars doesn't break when we have relationships)
self.assertEqual(len(gp_pv.GetPrimvars()), numPrimvars)
self.assertEqual(handleid.Get(), gp.GetPath())
stringPath = '/my/string/path'
self.assertTrue(handleid.SetIdTarget(stringPath))
self.assertEqual(handleid.Get(), Sdf.Path(stringPath))
p = Sdf.Path('/does/not/exist')
self.assertTrue(handleid.SetIdTarget(p))
self.assertEqual(handleid.Get(), p)
handleid_array = gp_pv.CreatePrimvar('handleid_array',
Sdf.ValueTypeNames.StringArray)
self.assertTrue(handleid_array.SetIdTarget(gp.GetPath()))
def _ValidatePxrDistantLightAngle(self):
nodePath = '|RfMLightsTest|Lights|DistantLight|DistantLightShape'
expectedAngle = 0.73
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.angleExtent' % nodePath),
expectedAngle, 1e-6))
def runTest(self):
for Size in Sizes:
# constructors
self.assertIsInstance(Size(), Size)
self.assertIsInstance(Size(Size()), Size)
if Size.dimension == 2:
self.assertIsInstance(Size(Gf.Vec2i()), Size)
self.assertIsInstance(Size(3, 4), Size)
s = Size()
self.assertEqual(s.Set(3, 4), Size(3, 4))
elif Size.dimension == 3:
self.assertIsInstance(Size(Gf.Vec3i()), Size)
self.assertIsInstance(Size(3, 4, 5), Size)
s = Size()
self.assertEqual(s.Set(3, 4, 5), Size(3, 4, 5))
s = makeValue(Size, (1, 2, 3))
self.assertEqual(s, makeValue(Size, (1, 2, 3)))
s = makeValue(Size, (1, 2, 3))
self.assertNotEqual(s, makeValue(Size, (3, 2, 1)))
s1 = makeValue(Size, (1, 2, 3))
s2 = makeValue(Size, (3, 4, 5))
self.assertEqual(s1 + s2, makeValue(Size, (4, 6, 8)))
self.assertEqual(s2 - s1, makeValue(Size, (2, 2, 2)))
self.assertEqual(s1 * s2, makeValue(Size, (3, 8, 15)))
s1 = makeValue(Size, (1, 2, 3))
s1_original = s1
s1 -= makeValue(Size, (1, 1, 1))
self.assertEqual(s1, makeValue(Size, (0, 1, 2)))
self.assertTrue(s1 is s1_original)
s1 = makeValue(Size, (1, 2, 3))
s1_original = s1
s1 += makeValue(Size, (1, 1, 1))
self.assertEqual(s1, makeValue(Size, (2, 3, 4)))
self.assertTrue(s1 is s1_original)
s1 = makeValue(Size, (1, 2, 3))
s1_original = s1
s1 *= 10
self.assertEqual(s1, makeValue(Size, (10, 20, 30)))
self.assertTrue(s1 is s1_original)
s1 = makeValue(Size, (30, 60, 90))
s1_original = s1
s1 /= 10
self.assertEqual(s1, makeValue(Size, (3, 6, 9)))
self.assertTrue(s1 is s1_original)
self.assertEqual(
makeValue(Size, (1, 2, 3)) * 10, makeValue(Size, (10, 20, 30)))
self.assertEqual(10 * makeValue(Size, (1, 2, 3)),
makeValue(Size, (10, 20, 30)))
self.assertEqual(
makeValue(Size, (10, 20, 30)) / 10, makeValue(Size, (1, 2, 3)))
self.assertEqual(s1, eval(repr(s1)))
self.assertTrue(len(str(makeValue(Size, (1, 2, 3)))))
# indexing
s = Size()
s[-1] = 3
self.assertEqual(s[-1], 3)
self.assertTrue(3 in s)
self.assertEqual(len(s), s.dimension)
s = makeValue(Size, (1, 2, 3))
self.assertTrue(not 10 in s)
# expect error
with self.assertRaises(IndexError):
s[-10] = 3
def test_PrimvarsAPI(self):
IsPrimvar = UsdGeom.Primvar.IsPrimvar
# We'll put all our Primvar on a single mesh gprim
stage = Usd.Stage.CreateInMemory('myTest.usda')
gp = UsdGeom.Mesh.Define(stage, '/myMesh')
gp_pv = UsdGeom.PrimvarsAPI(gp)
nPasses = 3
# Add three Primvars
u1 = gp_pv.CreatePrimvar('u_1', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(u1.NameContainsNamespaces())
self.assertEqual(UsdGeom.Primvar.StripPrimvarsName(u1.GetName()),
"u_1")
# Make sure it's OK to manually specify the classifier namespace
v1 = gp_pv.CreatePrimvar('primvars:v_1', Sdf.ValueTypeNames.FloatArray)
self.assertEqual(UsdGeom.Primvar.StripPrimvarsName(v1.GetName()),
"v_1")
noPrimvarsPrefixName = "noPrimvarPrefixName"
self.assertEqual(
UsdGeom.Primvar.StripPrimvarsName(noPrimvarsPrefixName),
noPrimvarsPrefixName)
self.assertFalse(v1.NameContainsNamespaces())
_3dpmats = gp_pv.CreatePrimvar('projMats',
Sdf.ValueTypeNames.Matrix4dArray,
"constant", nPasses)
# ensure we can create a primvar that contains namespaces!
primvarName = 'skel:jointWeights'
jointWeights = gp_pv.CreatePrimvar(primvarName,
Sdf.ValueTypeNames.FloatArray)
self.assertTrue(IsPrimvar(jointWeights))
self.assertTrue(
UsdGeom.Primvar.IsValidPrimvarName(jointWeights.GetName()))
self.assertTrue(jointWeights.NameContainsNamespaces())
self.assertEqual(primvarName, jointWeights.GetPrimvarName())
# Ensure we cannot create a primvar named indices or any namespace
# ending in indices
with self.assertRaises(Tf.ErrorException):
gp_pv.CreatePrimvar("indices", Sdf.ValueTypeNames.IntArray)
with self.assertRaises(Tf.ErrorException):
gp_pv.CreatePrimvar("multi:aggregate:indices",
Sdf.ValueTypeNames.IntArray)
self.assertEqual(len(gp_pv.GetAuthoredPrimvars()), 4)
# displayColor and displayOpacity are builtins, not authored
self.assertEqual(len(gp_pv.GetPrimvars()), 6)
# Now add some random properties, plus a "manually" created, namespaced
# primvar, and reverify
p = gp.GetPrim()
p.CreateRelationship("myBinding")
p.CreateAttribute("myColor", Sdf.ValueTypeNames.Color3f)
p.CreateAttribute("primvars:some:overly:namespaced:Color",
Sdf.ValueTypeNames.Color3f)
datas = gp_pv.GetAuthoredPrimvars()
self.assertEqual(len(datas), 5)
self.assertTrue(IsPrimvar(datas[0]))
self.assertTrue(UsdGeom.Primvar.IsValidPrimvarName(datas[0].GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(datas[0].GetName()))
self.assertTrue(IsPrimvar(datas[1]))
self.assertTrue(UsdGeom.Primvar.IsValidPrimvarName(datas[1].GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(datas[1].GetName()))
# For variety, test the explicit Attribute extractor
self.assertTrue(IsPrimvar(datas[2].GetAttr()))
self.assertTrue(
UsdGeom.Primvar.IsValidPrimvarName(datas[2].GetAttr().GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(
datas[2].GetAttr().GetName()))
self.assertFalse(IsPrimvar(p.GetAttribute("myColor")))
self.assertFalse(UsdGeom.Primvar.IsValidPrimvarName("myColor"))
self.assertFalse(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName("myColor"))
# Here we're testing that the speculative constructor fails properly
self.assertFalse(IsPrimvar(UsdGeom.Primvar(p.GetAttribute("myColor"))))
self.assertFalse(
UsdGeom.Primvar.IsValidPrimvarName(
datas[0].GetIndicesAttr().GetName()))
self.assertTrue(
UsdGeom.Primvar.IsPrimvarRelatedPropertyName(
datas[0].GetIndicesAttr().GetName()))
# And here that the speculative constructor succeeds properly
self.assertTrue(
IsPrimvar(UsdGeom.Primvar(p.GetAttribute(v1.GetName()))))
# Some of the same tests, exercising the bool-type operator
# for UsdGeomPrimvar; Primvar provides the easiest way to get INvalid attrs!
self.assertTrue(datas[0])
self.assertTrue(datas[1])
self.assertTrue(datas[2])
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myColor")))
self.assertFalse(UsdGeom.Primvar(p.GetAttribute("myBinding")))
self.assertTrue(UsdGeom.Primvar(p.GetAttribute(v1.GetName())))
# Same classification test through GprimSchema API
self.assertTrue(gp_pv.HasPrimvar('u_1'))
self.assertTrue(gp_pv.HasPrimvar('v_1'))
self.assertTrue(gp_pv.HasPrimvar('projMats'))
self.assertTrue(gp_pv.HasPrimvar('skel:jointWeights'))
self.assertFalse(gp_pv.HasPrimvar('myColor'))
self.assertFalse(gp_pv.HasPrimvar('myBinding'))
# Test that the gpv's returned by GetPrimvars are REALLY valid,
# and that the UsdAttribute metadata wrappers work
self.assertEqual(datas[0].GetTypeName(),
Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(datas[3].GetTypeName(), Sdf.ValueTypeNames.FloatArray)
self.assertEqual(datas[4].GetBaseName(), "v_1")
# Now we'll add some extra configuration and verify that the
# interrogative API works properly
self.assertEqual(u1.GetInterpolation(),
UsdGeom.Tokens.constant) # fallback
self.assertFalse(u1.HasAuthoredInterpolation())
self.assertFalse(u1.HasAuthoredElementSize())
self.assertTrue(u1.SetInterpolation(UsdGeom.Tokens.vertex))
self.assertTrue(u1.HasAuthoredInterpolation())
self.assertEqual(u1.GetInterpolation(), UsdGeom.Tokens.vertex)
self.assertFalse(v1.HasAuthoredInterpolation())
self.assertFalse(v1.HasAuthoredElementSize())
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.uniform))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.varying))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.constant))
self.assertTrue(v1.SetInterpolation(UsdGeom.Tokens.faceVarying))
with self.assertRaises(Tf.ErrorException):
v1.SetInterpolation("frobosity")
# Should be the last good value set
self.assertEqual(v1.GetInterpolation(), "faceVarying")
self.assertTrue(_3dpmats.HasAuthoredInterpolation())
self.assertTrue(_3dpmats.HasAuthoredElementSize())
with self.assertRaises(Tf.ErrorException):
_3dpmats.SetElementSize(0)
# Failure to set shouldn't change the state...
self.assertTrue(_3dpmats.HasAuthoredElementSize())
self.assertTrue(_3dpmats.SetElementSize(nPasses))
self.assertTrue(_3dpmats.HasAuthoredElementSize())
# Make sure value Get/Set work
self.assertEqual(u1.Get(), None)
self.assertFalse(u1.IsIndexed())
self.assertFalse(u1.GetIndicesAttr())
self.assertEqual(u1.ComputeFlattened(), None)
uVal = Vt.FloatArray([1.1, 2.1, 3.1])
self.assertTrue(u1.Set(uVal))
self.assertEqual(u1.Get(), uVal)
# Make sure indexed primvars work
self.assertFalse(u1.IsIndexed())
indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
self.assertTrue(u1.SetIndices(indices))
self.assertTrue(u1.IsIndexed())
self.assertTrue(u1.GetIndicesAttr())
self.assertEqual(u1.GetIndices(), indices)
for a, b in zip(u1.ComputeFlattened(), [1.1, 2.1, 3.1, 3.1, 2.1, 1.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(), u1.Get())
indicesWithInvalid = Vt.IntArray([0, 3, 2, 2, -1, 0])
self.assertTrue(u1.SetIndices(indicesWithInvalid))
self.assertTrue(u1.ComputeFlattened() is None)
indicesWithInvalid = Vt.IntArray([4, 5, 6, 7, -1, 8])
self.assertTrue(u1.SetIndices(indicesWithInvalid))
self.assertTrue(u1.ComputeFlattened() is None)
self.assertEqual(u1.GetUnauthoredValuesIndex(), -1)
self.assertTrue(u1.SetUnauthoredValuesIndex(2))
self.assertEqual(u1.GetUnauthoredValuesIndex(), 2)
self.assertEqual(u1.GetTimeSamples(), [])
self.assertFalse(u1.ValueMightBeTimeVarying())
indicesAt1 = Vt.IntArray([1, 2, 0])
indicesAt2 = Vt.IntArray([])
uValAt1 = Vt.FloatArray([2.1, 3.1, 4.1])
uValAt2 = Vt.FloatArray([3.1, 4.1, 5.1])
self.assertTrue(u1.SetIndices(indicesAt1, 1.0))
self.assertEqual(u1.GetIndices(1.0), indicesAt1)
self.assertTrue(u1.Set(uValAt1, 1.0))
self.assertEqual(u1.Get(1.0), uValAt1)
self.assertEqual(u1.GetTimeSamples(), [1.0])
self.assertFalse(u1.ValueMightBeTimeVarying())
self.assertTrue(u1.SetIndices(indicesAt2, 2.0))
self.assertEqual(u1.GetIndices(2.0), indicesAt2)
self.assertTrue(u1.Set(uValAt2, 2.0))
self.assertEqual(u1.Get(2.0), uValAt2)
self.assertEqual(u1.GetTimeSamples(), [1.0, 2.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(0.5, 1.5)),
[1.0])
self.assertTrue(u1.ValueMightBeTimeVarying())
# Add more time-samples to u1
indicesAt0 = Vt.IntArray([])
uValAt3 = Vt.FloatArray([4.1, 5.1, 6.1])
self.assertTrue(u1.SetIndices(indicesAt0, 0.0))
self.assertEqual(u1.GetTimeSamples(), [0.0, 1.0, 2.0])
self.assertTrue(u1.Set(uValAt3, 3.0))
self.assertEqual(u1.GetTimeSamples(), [0.0, 1.0, 2.0, 3.0])
self.assertEqual(u1.GetTimeSamplesInInterval(Gf.Interval(1.5, 3.5)),
[2.0, 3.0])
for a, b in zip(u1.ComputeFlattened(1.0), [3.1, 4.1, 2.1]):
self.assertTrue(Gf.IsClose(a, b, 1e-5))
self.assertNotEqual(u1.ComputeFlattened(1.0), u1.Get(1.0))
self.assertTrue(len(u1.ComputeFlattened(2.0)) == 0)
self.assertNotEqual(u1.ComputeFlattened(2.0), u1.Get(2.0))
# Ensure that primvars with indices only authored at timeSamples
# (i.e. no default) are recognized as such.
u1Indices = u1.GetIndicesAttr()
self.assertTrue(u1Indices)
u1Indices.ClearDefault()
self.assertTrue(u1.IsIndexed())
# Finally, ensure the values returned by GetDeclarationInfo
# (on new Primvar objects, to test the GprimSchema API)
# is identical to the individual queries, and matches what we set above
nu1 = gp_pv.GetPrimvar("u_1")
(name, typeName, interpolation, elementSize) = nu1.GetDeclarationInfo()
self.assertEqual(name, u1.GetBaseName())
self.assertEqual(typeName, u1.GetTypeName())
self.assertEqual(interpolation, u1.GetInterpolation())
self.assertEqual(elementSize, u1.GetElementSize())
self.assertEqual(name, "u_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.vertex)
self.assertEqual(elementSize, 1)
nv1 = gp_pv.GetPrimvar("v_1")
(name, typeName, interpolation, elementSize) = nv1.GetDeclarationInfo()
self.assertEqual(name, v1.GetBaseName())
self.assertEqual(typeName, v1.GetTypeName())
self.assertEqual(interpolation, v1.GetInterpolation())
self.assertEqual(elementSize, v1.GetElementSize())
self.assertEqual(name, "v_1")
self.assertEqual(typeName, Sdf.ValueTypeNames.FloatArray)
self.assertEqual(interpolation, UsdGeom.Tokens.faceVarying)
self.assertEqual(elementSize, 1)
nmats = gp_pv.GetPrimvar('projMats')
(name, typeName, interpolation,
elementSize) = nmats.GetDeclarationInfo()
self.assertEqual(name, _3dpmats.GetBaseName())
self.assertEqual(typeName, _3dpmats.GetTypeName())
self.assertEqual(interpolation, _3dpmats.GetInterpolation())
self.assertEqual(elementSize, _3dpmats.GetElementSize())
self.assertEqual(name, 'projMats')
self.assertEqual(typeName, Sdf.ValueTypeNames.Matrix4dArray)
self.assertEqual(interpolation, UsdGeom.Tokens.constant)
self.assertEqual(elementSize, nPasses)
# Custom builtins for gprim display primvars
displayColor = gp.CreateDisplayColorPrimvar(UsdGeom.Tokens.vertex, 3)
self.assertTrue(displayColor)
declInfo = displayColor.GetDeclarationInfo()
self.assertEqual(declInfo,
('displayColor', Sdf.ValueTypeNames.Color3fArray,
UsdGeom.Tokens.vertex, 3))
displayOpacity = gp.CreateDisplayOpacityPrimvar(
UsdGeom.Tokens.constant)
self.assertTrue(displayOpacity)
declInfo = displayOpacity.GetDeclarationInfo()
self.assertEqual(declInfo,
('displayOpacity', Sdf.ValueTypeNames.FloatArray,
UsdGeom.Tokens.constant, 1))
# Id primvar
notId = gp_pv.CreatePrimvar('notId', Sdf.ValueTypeNames.FloatArray)
self.assertFalse(notId.IsIdTarget())
with self.assertRaises(Tf.ErrorException):
notId.SetIdTarget(gp.GetPath())
handleid = gp_pv.CreatePrimvar('handleid', Sdf.ValueTypeNames.String)
# make sure we can still just set a string
v = "handleid_value"
self.assertTrue(handleid.Set(v))
self.assertEqual(handleid.Get(), v)
self.assertEqual(handleid.ComputeFlattened(), v)
numPrimvars = len(gp_pv.GetPrimvars())
# This check below ensures that the "indices" attributes belonging to
# indexed primvars aren't considered to be primvars themselves.
self.assertEqual(numPrimvars, 9)
self.assertTrue(handleid.SetIdTarget(gp.GetPath()))
# make sure we didn't increase the number of primvars (also that
# GetPrimvars doesn't break when we have relationships)
self.assertEqual(len(gp_pv.GetPrimvars()), numPrimvars)
self.assertEqual(handleid.Get(), gp.GetPath())
stringPath = '/my/string/path'
self.assertTrue(handleid.SetIdTarget(stringPath))
self.assertEqual(handleid.Get(), Sdf.Path(stringPath))
p = Sdf.Path('/does/not/exist')
self.assertTrue(handleid.SetIdTarget(p))
self.assertEqual(handleid.Get(), p)
handleid_array = gp_pv.CreatePrimvar('handleid_array',
Sdf.ValueTypeNames.StringArray)
self.assertTrue(handleid_array.SetIdTarget(gp.GetPath()))
# Test BlockPrimvar API
pv_blocking = gp_pv.CreatePrimvar('pvb', Sdf.ValueTypeNames.FloatArray)
pvName = pv_blocking.GetName()
pv_blocking.SetInterpolation(UsdGeom.Tokens.vertex)
pv_val = Vt.FloatArray([1.1, 2.1, 3.1])
pv_blocking.Set(pv_val)
# Block a non-indexed primvar should also construct and block indices attr
self.assertFalse(pv_blocking.IsIndexed())
self.assertTrue(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
gp_pv.BlockPrimvar(pvName)
self.assertFalse(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertFalse(pv_blocking.IsIndexed())
self.assertTrue(
pv_blocking.GetIndicesAttr().GetResolveInfo().ValueIsBlocked())
# re-set pv_blocking
pv_blocking.Set(pv_val)
pv_indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
pv_blocking.SetIndices(pv_indices)
self.assertTrue(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertTrue(pv_blocking.IsIndexed())
# Block primvar as well as indices Attr
gp_pv.BlockPrimvar(pvName)
self.assertFalse(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertFalse(pv_blocking.IsIndexed())
# re-set pv_blocking for further testing
pv_blocking.Set(pv_val)
pv_indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
pv_blocking.SetIndices(pv_indices)
# test BlockPrimvar on a referenced prim
weakLayer = Sdf.Layer.CreateAnonymous()
stageWeak = Usd.Stage.Open(weakLayer)
ovrMesh = stageWeak.OverridePrim('/myMesh')
ovrMesh.GetReferences().AddReference(stage.GetRootLayer().identifier,
'/myMesh')
gp_pv_ovr = UsdGeom.PrimvarsAPI(ovrMesh)
pv_blocking_ovr = gp_pv_ovr.GetPrimvar(pvName)
self.assertTrue(pv_blocking_ovr.HasAuthoredValue())
self.assertTrue(pv_blocking_ovr.HasAuthoredInterpolation())
self.assertTrue(pv_blocking_ovr.IsIndexed())
# should only block primvar and indices attr in the referenced prim
gp_pv_ovr.BlockPrimvar(pvName)
# ovr primvar will be blocked!
self.assertFalse(pv_blocking_ovr.HasAuthoredValue())
self.assertTrue(pv_blocking_ovr.HasAuthoredInterpolation())
self.assertFalse(pv_blocking_ovr.IsIndexed())
# stronger layer wont get affected and original prim should not be blocked
self.assertTrue(pv_blocking.HasAuthoredValue())
self.assertTrue(pv_blocking.HasAuthoredInterpolation())
self.assertTrue(pv_blocking.IsIndexed())
# Remove a few valid primvar names
# without namespace
p = gp.GetPrim()
self.assertTrue(u1.IsIndexed())
u1Name = u1.GetName()
u1IndicesAttrName = u1.GetIndicesAttr().GetName()
# can not remove a primvar across a reference arc
weakLayer = Sdf.Layer.CreateAnonymous()
stageWeak = Usd.Stage.Open(weakLayer)
ovrMesh = stageWeak.OverridePrim('/myMesh')
ovrMesh.GetReferences().AddReference(stage.GetRootLayer().identifier,
'/myMesh')
gp_pv_ovr = UsdGeom.PrimvarsAPI(ovrMesh)
self.assertTrue(gp_pv_ovr.HasPrimvar(u1Name))
self.assertFalse(gp_pv_ovr.RemovePrimvar(u1Name))
self.assertTrue(gp_pv_ovr.GetPrim().HasAttribute(u1Name))
# remove indexed primvar
self.assertTrue(gp_pv.RemovePrimvar(u1Name))
self.assertFalse(p.HasAttribute(u1Name))
self.assertFalse(p.HasAttribute(u1IndicesAttrName))
# with primvars namespace
v1Name = v1.GetName()
self.assertTrue(gp_pv.RemovePrimvar(v1Name))
self.assertFalse(p.HasAttribute(v1Name))
# primvar does not exists
self.assertFalse(gp_pv.RemovePrimvar('does_not_exist'))
self.assertFalse(gp_pv.RemovePrimvar('does_not_exist:does_not_exist'))
# try to remove an invalid primvar with restricted tokens, "indices"
with self.assertRaises(Tf.ErrorException):
gp_pv.RemovePrimvar('indices')
with self.assertRaises(Tf.ErrorException):
gp_pv.RemovePrimvar('multi:aggregate:indices')
# create Indices primvar using CreateIndexedPrimvar API
uVal = Vt.FloatArray([1.1, 2.1, 3.1])
indices = Vt.IntArray([0, 1, 2, 2, 1, 0])
indexedPrimvar = gp_pv.CreateIndexedPrimvar(
'indexedPrimvar', Sdf.ValueTypeNames.FloatArray, uVal, indices,
UsdGeom.Tokens.vertex)
self.assertTrue(indexedPrimvar.IsIndexed())
self.assertTrue(indexedPrimvar.HasAuthoredValue())
self.assertTrue(indexedPrimvar.HasAuthoredInterpolation())
# mimic a Pixar production workflow of creating primvars
# 1. show usage with CreatePrimvar
# 2. show usage with CreateNonIndexedPrimvar
# - create a primvar in base layer
# - override this primvar in a stronger layer
# - update primvar in base layer to use indices
# - test if primvar has indices blocked in strong layer or not!
# Create primvar in base layer using CreatePrimvar api and set value
basePrimvar1 = gp_pv.CreatePrimvar('pv1',
Sdf.ValueTypeNames.FloatArray)
basePrimvar1.Set(uVal)
# Create primvar in base layer using CreatePrimvar api and set value
basePrimvar2 = gp_pv.CreatePrimvar('pv2',
Sdf.ValueTypeNames.FloatArray)
basePrimvar2.Set(uVal)
# stronger layer
strongLayer = Sdf.Layer.CreateAnonymous()
strongStage = Usd.Stage.Open(strongLayer)
# over Mesh prim and add reference
oMesh = strongStage.OverridePrim('/myMesh')
oMesh.GetReferences().AddReference(stage.GetRootLayer().identifier,
'/myMesh')
# over primvarsApi instance
gp_pv_ovr = UsdGeom.PrimvarsAPI(oMesh)
# override value for primvar
oVal = Vt.FloatArray([2.2, 3.2, 4.2])
# override pv1 using CreatePrimvar api
oBasePrimvar1 = gp_pv_ovr.CreatePrimvar('pv1',
Sdf.ValueTypeNames.FloatArray)
oBasePrimvar1.Set(oVal)
# override pv2 using CreateNonIndexedPrimvar api
oBasePrimvar2 = gp_pv_ovr.CreateNonIndexedPrimvar(
'pv2', Sdf.ValueTypeNames.FloatArray, oVal)
# test indices attr missing on oBasePrimvar1
self.assertFalse(oBasePrimvar1.GetIndicesAttr().IsValid())
# test oBasePrimvar2's indices attribute has a block authored
self.assertFalse(oBasePrimvar2.IsIndexed())
self.assertTrue(
oBasePrimvar2.GetIndicesAttr().GetResolveInfo().ValueIsBlocked())
# update base (weaker) layer primvars to have an indices
basePrimvar1.SetIndices(indices)
basePrimvar2.SetIndices(indices)
# ovr pv1 should now get indices
self.assertTrue(oBasePrimvar1.IsIndexed())
# ovr pv2 should still have the block for indices
self.assertFalse(oBasePrimvar2.IsIndexed())
self.assertTrue(
oBasePrimvar2.GetIndicesAttr().GetResolveInfo().ValueIsBlocked())
def test_TupleToVec(self):
# Test passing tuples for vecs.
self.assertEqual(Gf.Dot((1, 1), (1, 1)), 2)
self.assertEqual(Gf.Dot((1, 1, 1), (1, 1, 1)), 3)
self.assertEqual(Gf.Dot((1, 1, 1, 1), (1, 1, 1, 1)), 4)
self.assertEqual(Gf.Dot((1.0, 1.0), (1.0, 1.0)), 2.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0), (1.0, 1.0, 1.0)), 3.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0, 1.0)),
4.0)
self.assertEqual(Gf.Vec2f((1, 1)), Gf.Vec2f(1, 1))
self.assertEqual(Gf.Vec3f((1, 1, 1)), Gf.Vec3f(1, 1, 1))
self.assertEqual(Gf.Vec4f((1, 1, 1, 1)), Gf.Vec4f(1, 1, 1, 1))
# Test passing lists for vecs.
self.assertEqual(Gf.Dot([1, 1], [1, 1]), 2)
self.assertEqual(Gf.Dot([1, 1, 1], [1, 1, 1]), 3)
self.assertEqual(Gf.Dot([1, 1, 1, 1], [1, 1, 1, 1]), 4)
self.assertEqual(Gf.Dot([1.0, 1.0], [1.0, 1.0]), 2.0)
self.assertEqual(Gf.Dot([1.0, 1.0, 1.0], [1.0, 1.0, 1.0]), 3.0)
self.assertEqual(Gf.Dot([1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]),
4.0)
self.assertEqual(Gf.Vec2f([1, 1]), Gf.Vec2f(1, 1))
self.assertEqual(Gf.Vec3f([1, 1, 1]), Gf.Vec3f(1, 1, 1))
self.assertEqual(Gf.Vec4f([1, 1, 1, 1]), Gf.Vec4f(1, 1, 1, 1))
# Test passing both for vecs.
self.assertEqual(Gf.Dot((1, 1), [1, 1]), 2)
self.assertEqual(Gf.Dot((1, 1, 1), [1, 1, 1]), 3)
self.assertEqual(Gf.Dot((1, 1, 1, 1), [1, 1, 1, 1]), 4)
self.assertEqual(Gf.Dot((1.0, 1.0), [1.0, 1.0]), 2.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0), [1.0, 1.0, 1.0]), 3.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0, 1.0), [1.0, 1.0, 1.0, 1.0]),
4.0)
self.assertEqual(Gf.Vec2f([1, 1]), Gf.Vec2f(1, 1))
self.assertEqual(Gf.Vec3f([1, 1, 1]), Gf.Vec3f(1, 1, 1))
self.assertEqual(Gf.Vec4f([1, 1, 1, 1]), Gf.Vec4f(1, 1, 1, 1))
def AssertBBoxesClose(cachedBox, directBox, msg):
cachedRange = cachedBox.ComputeAlignedRange()
directRange = directBox.ComputeAlignedRange()
assert Gf.IsClose(cachedRange.min, directRange.min, 1e-5), msg
assert Gf.IsClose(cachedRange.max, directRange.max, 1e-5), msg
def test_Properties(self):
f = Gf.Frustum()
f.position = Gf.Vec3d(1, 2, 3)
self.assertEqual(f.position, Gf.Vec3d(1, 2, 3))
f.rotation = Gf.Rotation(Gf.Vec3d(1, 1, 1), 30)
self.assertEqual(f.rotation, Gf.Rotation(Gf.Vec3d(1, 1, 1), 30))
f.window = Gf.Range2d(Gf.Vec2d(0, 1), Gf.Vec2d(2, 3))
self.assertEqual(f.window, Gf.Range2d(Gf.Vec2d(0, 1), Gf.Vec2d(2, 3)))
f.nearFar = Gf.Range1d(1, 2)
self.assertEqual(f.nearFar, Gf.Range1d(1, 2))
f.viewDistance = 10
self.assertEqual(f.viewDistance, 10)
f.projectionType = Gf.Frustum.Orthographic
self.assertEqual(f.projectionType, Gf.Frustum.Orthographic)
f.projectionType = Gf.Frustum.Perspective
self.assertEqual(f.projectionType, Gf.Frustum.Perspective)
def test_Basic(self):
"""Sanity tests for Usd.TimeCode API"""
default1 = Usd.TimeCode.Default()
default2 = Usd.TimeCode.Default()
self.assertEqual(default1, default2)
earliestTime1 = Usd.TimeCode.EarliestTime()
earliestTime2 = Usd.TimeCode.EarliestTime()
self.assertEqual(earliestTime1, earliestTime2)
nonSpecial = Usd.TimeCode(24.0)
self.assertNotEqual(default1, nonSpecial)
self.assertNotEqual(earliestTime1, nonSpecial)
print default1, default2, nonSpecial, earliestTime1, earliestTime2
# test relational operators and hash.
time1 = Usd.TimeCode(1.0)
time2 = Usd.TimeCode(2.0)
self.assertTrue(time1 == Usd.TimeCode(1.0))
self.assertTrue(time2 == Usd.TimeCode(2.0))
self.assertTrue(time1 != Usd.TimeCode(2.0))
self.assertTrue(time2 != Usd.TimeCode(1.0))
self.assertTrue(time1 != time2)
self.assertTrue(time1 < time2)
self.assertTrue(time1 <= time2)
self.assertTrue(time2 > time1)
self.assertTrue(time2 >= time1)
self.assertTrue(not (time1 < time1))
self.assertTrue(time1 <= time1)
self.assertTrue(not (time1 > time1))
self.assertTrue(time1 >= time1)
self.assertTrue(default1 < time1)
self.assertTrue(default1 <= time1)
self.assertTrue(time1 > default1)
self.assertTrue(time1 >= default1)
self.assertTrue(default1 < earliestTime1)
self.assertTrue(default1 <= earliestTime1)
self.assertTrue(time1 > earliestTime1)
self.assertTrue(time1 >= earliestTime1)
self.assertTrue(hash(default1) == hash(default2))
self.assertTrue(hash(earliestTime1) == hash(earliestTime2))
self.assertTrue(hash(default1) != hash(earliestTime1))
self.assertTrue(hash(Usd.TimeCode(1.234)) == hash(Usd.TimeCode(1.234)))
self.assertTrue(hash(time1) != hash(time2))
# Basic tests for SafeStep.
d = Usd.TimeCode.SafeStep()
self.assertTrue(
Usd.TimeCode(1e6 + d) != 1e6 and Usd.TimeCode(1e6 + d) > 1e6)
self.assertTrue(Usd.TimeCode(1e12 +
d) == 1e12) # <- aliases at this scale
d = Usd.TimeCode.SafeStep(maxValue=1e12)
self.assertTrue(Usd.TimeCode(1e12 + d) != 1e12)
# with our factor of 2 safety margin, two values separated by delta at twice
# the max, scaled down by the max scale factor, then shifted back out to the
# max (not scaled) should still be distinct.
d = Usd.TimeCode.SafeStep()
t1, t2 = (1e6 * 2) / 10.0, (1e6 * 2 + d) / 10.0
self.assertTrue(t1 != t2 and t1 < t2)
# shift them over so they're back at twice the max.
self.assertTrue((t1 + 1800000.0) != (t2 + 1800000.0)
and (t1 + 1800000.0) < (t2 + 1800000.0))
# do same test but instead of twice the max, test twice the shrinkage.
d = Usd.TimeCode.SafeStep()
t1, t2 = (1e6) / 20.0, (1e6 + d) / 20.0
self.assertTrue(t1 != t2 and t1 < t2)
# shift them over so they're back at twice the max.
self.assertTrue((t1 + 950000.0) != (t2 + 950000.0)
and (t1 + 950000.0) < (t2 + 950000.0))
# Assert that invoking GetValue() on Default time raises.
# with self.assertRaises(RuntimeError):
# Usd.TimeCode.Default().GetValue()
allFormats = ['usd' + x for x in 'ac']
for fmt in allFormats:
layerName = "testUsdTimeSamples." + fmt
if os.path.exists(layerName):
os.unlink(layerName)
stage = Usd.Stage.CreateNew(layerName)
l = stage.GetRootLayer()
prim = stage.OverridePrim("/Test")
attr = prim.CreateAttribute("varying", Sdf.ValueTypeNames.Int)
attr.Set(0)
attr.Set(1, 1)
attr.Set(2, 2)
sdVaryingAttr = l.GetAttributeAtPath(attr.GetPath())
self.assertEqual(l.ListTimeSamplesForPath(attr.GetPath()),
[1.0, 2.0])
self.assertEqual(attr.GetTimeSamples(), [1.0, 2.0])
self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0, 1)),
[1.0])
self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0, 6)),
[1.0, 2.0])
self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0, 0)),
[])
self.assertEqual(
attr.GetTimeSamplesInInterval(Gf.Interval(1.0, 2.0)),
[1.0, 2.0])
# ensure that open, finite endpoints are disallowed
with self.assertRaises(Tf.ErrorException):
# IsClosed() will be True by default in the Interval ctor
bothClosed = Gf.Interval(1.0, 2.0, False, False)
attr.GetTimeSamplesInInterval(bothClosed)
with self.assertRaises(Tf.ErrorException):
finiteMinClosed = Gf.Interval(1.0, 2.0, True, False)
attr.GetTimeSamplesInInterval(finiteMinClosed)
with self.assertRaises(Tf.ErrorException):
finiteMaxClosed = Gf.Interval(1.0, 2.0, False, True)
attr.GetTimeSamplesInInterval(finiteMaxClosed)
self.assertEqual(attr.GetBracketingTimeSamples(1.5), (1.0, 2.0))
self.assertEqual(attr.GetBracketingTimeSamples(1.0), (1.0, 1.0))
self.assertEqual(attr.GetBracketingTimeSamples(2.0), (2.0, 2.0))
self.assertEqual(attr.GetBracketingTimeSamples(.9), (1.0, 1.0))
self.assertEqual(
attr.GetBracketingTimeSamples(earliestTime1.GetValue()),
(1.0, 1.0))
self.assertEqual(attr.GetBracketingTimeSamples(2.1), (2.0, 2.0))
# XXX: I would like to verify timeSamples here using the Sd API
# but GetInfo fails to convert the SdTimeSampleMap back to
# python correctly, and SetInfo does not convert a python
# dictionary back to C++ correctly.
#d = sdVaryingAttr.GetInfo("timeSamples")
#d[1.0] = 99
#d[2.0] = 42
#sdVaryingAttr.SetInfo("timeSamples", d)
#self.assertEqual(l.ListTimeSamplesForPath(attr.GetPath()), [99.0,42.0])
attr = prim.CreateAttribute("unvarying", Sdf.ValueTypeNames.Int)
attr.Set(0)
sdUnvaryingAttr = l.GetAttributeAtPath(attr.GetPath())
self.assertEqual(l.ListTimeSamplesForPath(attr.GetPath()), [])
self.assertEqual(attr.GetTimeSamples(), [])
self.assertEqual(
attr.GetTimeSamplesInInterval(Gf.Interval.GetFullInterval()),
[])
self.assertEqual(attr.GetBracketingTimeSamples(1.5), ())
# Test for bug/81006 . Could break this out into a separate test, but
# given the ratio of setup to test, figured I'd stick it in here. This
# will segfault if the fix is really not working.
empty = Vt.DoubleArray()
emptyAttr = prim.CreateAttribute("empty",
Sdf.ValueTypeNames.DoubleArray)
emptyAttr.Set(empty)
roundEmpty = emptyAttr.Get(Usd.TimeCode.Default())
# See bug/81998 why we cannot test for equality here
self.assertEqual(len(roundEmpty), len(empty))
# print the layer contents for debugging
print l.ExportToString()
self.assertEqual(sdUnvaryingAttr.HasInfo("timeSamples"), False)
self.assertEqual(sdVaryingAttr.HasInfo("timeSamples"), True)
def test_Operators(self):
f1 = Gf.Frustum()
f2 = Gf.Frustum(f1)
self.assertEqual(f1, f2)
def test_Position(self):
f1 = Gf.Frustum()
f2 = Gf.Frustum()
f1.position = Gf.Vec3d(1, 0, 0)
f2.position = Gf.Vec3d(0, 1, 0)
self.assertNotEqual(f1, f2)
def test_ConstructFromMatrix(self):
m = Gf.Matrix4d(0.9987016645043332, -0.035803686178599,
-0.036236464677155, 0.0, 0.0362364646771555,
0.999278702502407, 0.011357524061459, 0.0,
0.0358036861785999, -0.012655859557126,
0.999278702502407, 0.0, 3.0, -6.0, 5.0, 1.0)
f = Gf.Frustum(m, Gf.Range2d(Gf.Vec2d(-0.22,
-0.2), Gf.Vec2d(0.2, 0.33)),
Gf.Range1d(20, 90), Gf.Frustum.Perspective)
f = Gf.Frustum(m, Gf.Range2d(Gf.Vec2d(-0.22,
-0.2), Gf.Vec2d(0.2, 0.33)),
Gf.Range1d(20, 90), Gf.Frustum.Perspective)
corners = f.ComputeCorners()
results = (Gf.Vec3d(-2.255306906099, -9.58646139968125,
-14.8715637017144),
Gf.Vec3d(6.133787075736, -9.88721236358150,
-15.1759500050026),
Gf.Vec3d(-1.871200380521, 1.00589284684426,
-14.7511739466630),
Gf.Vec3d(6.517893601314, 0.70514188294401,
-15.0555602499511),
Gf.Vec3d(-20.648881077448, -22.13907629856565,
-84.4220366577152),
Gf.Vec3d(17.102041840815, -23.49245563611677,
-85.7917750225117),
Gf.Vec3d(-18.920401712348, 25.52651781079917,
-83.8802827599836),
Gf.Vec3d(18.830521205915, 24.17313847324806,
-85.2500211247801))
self.assertEqual(len(corners), len(results))
for i in range(len(results)):
self.assertTrue(Gf.IsClose(corners[i], results[i], 0.0001))
corners = f.ComputeCornersAtDistance(20)
for i in range(len(corners)):
self.assertTrue(Gf.IsClose(corners[i], results[i], 0.0001))
corners = f.ComputeCornersAtDistance(90)
for i in range(len(corners)):
self.assertTrue(Gf.IsClose(corners[i], results[i + 4], 0.0001))
corners = f.ComputeCornersAtDistance((20 + 90) / 2.0)
for i in range(len(corners)):
self.assertTrue(
Gf.IsClose(corners[i], (results[i] + results[i + 4]) / 2.0,
0.0001))
def test_Serialization(self):
f = Gf.Frustum(Gf.Vec3d(3, 4, 5),
Gf.Rotation((1, 2, 3), 40),
Gf.Range2d(Gf.Vec2d(-0.2, -0.3), Gf.Vec2d(0.2, 0.33)),
Gf.Range1d(10, 100),
Gf.Frustum.Perspective,
viewDistance=20)
f2 = eval(repr(f))
f3 = Gf.Frustum(rotation=Gf.Rotation((1, 2, 3), 40),
nearFar=Gf.Range1d(10, 100),
projectionType=Gf.Frustum.Perspective,
position=Gf.Vec3d(3, 4, 5),
viewDistance=20,
window=Gf.Range2d(Gf.Vec2d(-0.2, -0.3),
Gf.Vec2d(0.2, 0.33)))
self.assertAlmostEqual(f, f2)
self.assertAlmostEqual(f, f3)
self.assertAlmostEqual(f.viewDistance, 20.0)
self.assertAlmostEqual(f2.viewDistance, 20.0)
def test_IntersectionViewVolume(self):
# a viewProjMat corresponding to a persp cam looking down the Y axis,
# aimed at the origin.
viewMat = Gf.Matrix4d(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0,
1.0, 0.0, 0.0, 0.0, 0.0, -20, 1.0)
projMat = Gf.Matrix4d(4.241894005673533, 0.0, 0.0, 0.0, 0.0,
4.2418940586972074, 0.0, 0.0, 0.0, 0.0, -1, -1.0,
0.0, 0.0, -20, 0.0)
viewProjMat = viewMat * projMat
# a typical box entirely in the view
b = Gf.BBox3d(Gf.Range3d(Gf.Vec3d(0, 0, 0), Gf.Vec3d(1, 1, 1)))
self.assertTrue(Gf.Frustum.IntersectsViewVolume(b, viewProjMat))
# a typical box entirely out of the view
b = Gf.BBox3d(Gf.Range3d(Gf.Vec3d(100, 0, 0), Gf.Vec3d(101, 1, 1)))
self.assertFalse(Gf.Frustum.IntersectsViewVolume(b, viewProjMat))
# a large box entirely enclosing the view
b = Gf.BBox3d(
Gf.Range3d(Gf.Vec3d(-1e9, -1e9, -1e9), Gf.Vec3d(1e9, 1e9, 1e9)))
self.assertTrue(Gf.Frustum.IntersectsViewVolume(b, viewProjMat))
def OperatorsTest(self, Vec):
v1 = Vec()
v2 = Vec()
# equality
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [3, 1, 4, 1])
self.assertEqual(v1, v2)
# inequality
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
self.assertNotEqual(v1, v2)
# component-wise addition
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v3 = v1 + v2
v1 += v2
self.assertTrue(checkVec(v1, [8, 10, 6, 7]))
self.assertTrue(checkVec(v3, [8, 10, 6, 7]))
# component-wise subtraction
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v3 = v1 - v2
v1 -= v2
self.assertTrue(checkVec(v1, [-2, -8, 2, -5]))
self.assertTrue(checkVec(v3, [-2, -8, 2, -5]))
# component-wise multiplication
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v4 = v1 * 10
v5 = 10 * v1
v1 *= 10
self.assertTrue(checkVec(v1, [30, 10, 40, 10]))
self.assertTrue(checkVec(v4, [30, 10, 40, 10]))
self.assertTrue(checkVec(v5, [30, 10, 40, 10]))
# component-wise division
SetVec(v1, [3, 6, 9, 12])
v3 = v1 / 3
v1 /= 3
self.assertTrue(checkVec(v1, [1, 2, 3, 4]))
self.assertTrue(checkVec(v3, [1, 2, 3, 4]))
# dot product
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
dp = v1 * v2
dp2 = Gf.Dot(v1, v2)
dp3 = v1.GetDot(v2) # 2x compatibility
self.assertTrue(checkVecDot(v1, v2, dp))
self.assertTrue(checkVecDot(v1, v2, dp2))
self.assertTrue(checkVecDot(v1, v2, dp3))
# unary minus (negation)
SetVec(v1, [3, 1, 4, 1])
self.assertTrue(checkVec(-v1, [-3, -1, -4, -1]))
# repr
self.assertEqual(v1, eval(repr(v1)))
# string
self.assertTrue(len(str(Vec())) > 0)
# indexing
v = Vec()
for i in range(Vec.dimension):
v[i] = i + 1
self.assertEqual(v[-1], v[v.dimension - 1])
self.assertEqual(v[0], 1)
self.assertIn(v.dimension, v)
self.assertNotIn(v.dimension + 1, v)
with self.assertRaises(IndexError):
v[v.dimension + 1] = v.dimension + 1
# slicing
v = Vec()
value = [3, 1, 4, 1]
SetVec(v, value)
value = v[0:v.dimension]
self.assertEqual(v[:], value)
self.assertEqual(v[:2], value[:2])
self.assertEqual(v[0:2], value[0:2])
self.assertEqual(v[-2:], value[-2:])
self.assertEqual(v[1:1], [])
if v.dimension > 2:
self.assertEqual(v[0:3:2], [3, 4])
v[:2] = (8, 9)
checkVec(v, [8, 9, 4, 1])
if v.dimension > 2:
v[:3:2] = [0, 1]
checkVec(v, [0, 9, 1, 1])
with self.assertRaises(ValueError):
# This should fail. Wrong length sequence
#
v[:2] = [1, 2, 3]
with self.assertRaises(TypeError):
# This should fail. Cannot use floats for indices
v[0.0:2.0] = [7, 7]
with self.assertRaises(TypeError):
# This should fail. Cannot convert None to vector data
#
v[:2] = [None, None]
def test_Fitting(self):
# Collinear points should not define a plane.
a = Gf.Vec3d(0, 0, 0)
b = Gf.Vec3d(1, 0, 0)
c = Gf.Vec3d(2, 0, 0)
self.assertIsNone(Gf.FitPlaneToPoints([a, b, c]), err("collinear"))
# Cannot fit plane to 2 or fewer points.
with self.assertRaises(Tf.ErrorException):
Gf.FitPlaneToPoints([a, b])
# Perfect fit (normal should be parallel to Z-axis, but OK if opposite
# direction).
c = Gf.Vec3d(0, 1, 0)
p = Gf.FitPlaneToPoints([a, b, c])
self.assertAlmostEqual(Gf.Dot(p.GetNormal(), Gf.Vec3d.ZAxis()), 1.0,
msg=err("normal1"))
self.assertAlmostEqual(p.GetDistanceFromOrigin(), 0.0,
msg=err("distance1"))
# Try the same plane but with non-unit vectors.
b = Gf.Vec3d(1.5, 0, 0)
c = Gf.Vec3d(0, 3.2, 0)
p = Gf.FitPlaneToPoints([a, b, c])
self.assertAlmostEqual(Gf.Dot(p.GetNormal(), Gf.Vec3d.ZAxis()), 1.0,
msg=err("normal2"))
self.assertAlmostEqual(p.GetDistanceFromOrigin(), 0.0,
msg=err("distance2"))
# Try a more complicated plane.
p1 = Gf.Plane(Gf.Vec4d(3, 4, 0, 5)) # equation constructor
a = p1.Project(Gf.Vec3d(2, 3, 6))
b = p1.Project(Gf.Vec3d(34, -2, 2))
c = p1.Project(Gf.Vec3d(-3, 7, -8))
d = p1.Project(Gf.Vec3d(4, 1, 1))
e = p1.Project(Gf.Vec3d(87, 67, 92))
p2 = Gf.FitPlaneToPoints([a, b, c])
self.assertAlmostEqual(
Gf.Dot(p1.GetNormal(), p2.GetNormal()), 1.0,
msg=err("p2 normal parallel to p1"))
self.assertAlmostEqual(
p1.GetDistanceFromOrigin(),
p2.GetDistanceFromOrigin(),
msg=err("p2 distance equals p1"))
p3 = Gf.FitPlaneToPoints([a, b, c, d, e])
self.assertAlmostEqual(
Gf.Dot(p1.GetNormal(), p3.GetNormal()), 1.0,
msg=err("p3 normal parallel to p1"))
self.assertAlmostEqual(
p1.GetDistanceFromOrigin(),
p3.GetDistanceFromOrigin(),
msg=err("p3 distance equals p1"))
# Try fitting points that don't form a perfect plane.
# This roughly forms the plane with normal (1, -1, 0) passing through
# the origin.
# Decrease the number of places of accuracy since these points are
# fudged and don't form an exact plane.
a = Gf.Vec3d(1.1, 1, 5)
b = Gf.Vec3d(1, 1.1, 2)
c = Gf.Vec3d(2, 2.1, -4)
d = Gf.Vec3d(2.1, 2, 1)
e = Gf.Vec3d(25.3, 25.2, 3)
f = Gf.Vec3d(25.1, 25.4, 6)
p = Gf.FitPlaneToPoints([a, b, c, d, e, f])
expectedNormal = Gf.Vec3d(1, -1, 0).GetNormalized()
self.assertAlmostEqual(
Gf.Dot(p.GetNormal(), expectedNormal), 1.0,
places=2,
msg=err("normal3"))
self.assertAlmostEqual(
p.GetDistanceFromOrigin(), 0.0,
places=2,
msg=err("distance3"))
def MethodsTest(self, Vec):
v1 = Vec()
v2 = Vec()
if isFloatingPoint(Vec):
eps = getEps(Vec)
# length
SetVec(v1, [3, 1, 4, 1])
l = Gf.GetLength(v1)
l2 = v1.GetLength()
self.assertTrue(Gf.IsClose(l, l2, eps), repr(l) + ' ' + repr(l2))
self.assertTrue(Gf.IsClose(l, math.sqrt(Gf.Dot(v1, v1)), eps), \
' '.join([repr(x) for x in [l, v1, math.sqrt(Gf.Dot(v1, v1))]]))
# Normalize...
SetVec(v1, [3, 1, 4, 1])
v2 = Vec(v1)
v2.Normalize()
nv = Gf.GetNormalized(v1)
nv2 = v1.GetNormalized()
nvcheck = v1 / Gf.GetLength(v1)
self.assertTrue(Gf.IsClose(nv, nvcheck, eps))
self.assertTrue(Gf.IsClose(nv2, nvcheck, eps))
self.assertTrue(Gf.IsClose(v2, nvcheck, eps))
SetVec(v1, [3, 1, 4, 1])
nv = v1.GetNormalized()
nvcheck = v1 / Gf.GetLength(v1)
self.assertEqual(nv, nvcheck)
SetVec(v1, [0, 0, 0, 0])
v1.Normalize()
self.assertTrue(checkVec(v1, [0, 0, 0, 0]))
SetVec(v1, [2, 0, 0, 0])
Gf.Normalize(v1)
self.assertTrue(checkVec(v1, [1, 0, 0, 0]))
# projection
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
p1 = Gf.GetProjection(v1, v2)
p2 = v1.GetProjection(v2)
check = (v1 * v2) * v2
self.assertTrue((p1 == check) and (p2 == check))
# complement
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
p1 = Gf.GetComplement(v1, v2)
p2 = v1.GetComplement(v2)
check = v1 - (v1 * v2) * v2
self.assertTrue((p1 == check) and (p2 == check))
# component-wise multiplication
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v3 = Gf.CompMult(v1, v2)
self.assertTrue(checkVec(v3, [15, 9, 8, 6]))
# component-wise division
SetVec(v1, [3, 9, 18, 21])
SetVec(v2, [3, 3, 9, 7])
v3 = Gf.CompDiv(v1, v2)
self.assertTrue(checkVec(v3, [1, 3, 2, 3]))
# is close
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
self.assertTrue(Gf.IsClose(v1, v1, 0.1))
self.assertFalse(Gf.IsClose(v1, v2, 0.1))
# static Axis methods
for i in range(Vec.dimension):
v1 = Vec.Axis(i)
v2 = Vec()
v2[i] = 1
self.assertEqual(v1, v2)
v1 = Vec.XAxis()
self.assertTrue(checkVec(v1, [1, 0, 0, 0]))
v1 = Vec.YAxis()
self.assertTrue(checkVec(v1, [0, 1, 0, 0]))
if Vec.dimension != 2:
v1 = Vec.ZAxis()
self.assertTrue(checkVec(v1, [0, 0, 1, 0]))
if Vec.dimension == 3:
# cross product
SetVec(v1, [3, 1, 4, 0])
SetVec(v2, [5, 9, 2, 0])
v3 = Vec(Gf.Cross(v1, v2))
v4 = v1 ^ v2
v5 = v1.GetCross(v2) # 2x compatibility
check = Vec()
SetVec(check, [1 * 2 - 4 * 9, 4 * 5 - 3 * 2, 3 * 9 - 1 * 5, 0])
self.assertTrue(v3 == check and v4 == check and v5 == check)
# orthogonalize basis
# case 1: close to orthogonal, don't normalize
SetVec(v1, [1, 0, 0.1])
SetVec(v2, [0.1, 1, 0])
SetVec(v3, [0, 0.1, 1])
self.assertTrue(Vec.OrthogonalizeBasis(v1, v2, v3, False))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
# case 2: far from orthogonal, normalize
SetVec(v1, [1, 2, 3])
SetVec(v2, [-1, 2, 3])
SetVec(v3, [-1, -2, 3])
self.assertTrue(Vec.OrthogonalizeBasis(v1, v2, v3, True))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
self.assertTrue(Gf.IsClose(v1.GetLength(), 1, eps))
self.assertTrue(Gf.IsClose(v2.GetLength(), 1, eps))
self.assertTrue(Gf.IsClose(v3.GetLength(), 1, eps))
# case 3: already orthogonal - shouldn't change, even with large
# tolerance
SetVec(v1, [1, 0, 0])
SetVec(v2, [0, 1, 0])
SetVec(v3, [0, 0, 1])
vt1 = v1
vt2 = v2
vt3 = v3
self.assertTrue(Vec.OrthogonalizeBasis(v1, v2, v3, False, 1.0))
self.assertTrue(v1 == vt1)
self.assertTrue(v2 == vt2)
self.assertTrue(v3 == vt3)
# case 4: co-linear input vectors - should do nothing
SetVec(v1, [1, 0, 0])
SetVec(v2, [1, 0, 0])
SetVec(v3, [0, 0, 1])
vt1 = v1
vt2 = v2
vt3 = v3
self.assertFalse(Vec.OrthogonalizeBasis(
v1, v2, v3, False, 1.0))
self.assertEqual(v1, vt1)
self.assertEqual(v2, vt2)
self.assertEqual(v3, vt3)
# build orthonormal frame
SetVec(v1, [1, 1, 1, 1])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
SetVec(v1, [0, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(v2, Vec(), eps))
self.assertTrue(Gf.IsClose(v3, Vec(), eps))
SetVec(v1, [1, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
SetVec(v1, [1, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
SetVec(v1, [1, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame(2)
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
# test Slerp w/ orthogonal vectors
SetVec(v1, [1, 0, 0])
SetVec(v2, [0, 1, 0])
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(.7071, .7071, 0), eps))
# test Slerp w/ nearly parallel vectors
SetVec(v1, [1, 0, 0])
SetVec(v2, [1.001, 0.0001, 0])
v2.Normalize()
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps), [v3, v1, eps])
self.assertTrue(Gf.IsClose(v3, v2, eps))
# test Slerp w/ opposing vectors
SetVec(v1, [1, 0, 0])
SetVec(v2, [-1, 0, 0])
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(0.25, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(.70711, 0, -.70711), eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, 0, -1), eps))
v3 = Gf.Slerp(0.75, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(-.70711, 0, -.70711), eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
# test Slerp w/ opposing vectors
SetVec(v1, [0, 1, 0])
SetVec(v2, [0, -1, 0])
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(0.25, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, .70711, .70711), eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, 0, 1), eps))
v3 = Gf.Slerp(0.75, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, -.70711, .70711), eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
def test_Constructors(self):
self.assertIsInstance(Gf.Plane(), Gf.Plane, err( "constructor" ))
self.assertIsInstance(Gf.Plane(Gf.Vec3d(1,1,1), 1), Gf.Plane, err( "constructor" ))
self.assertIsInstance(Gf.Plane(Gf.Vec3d(1,1,1), Gf.Vec3d(1,1,1)), Gf.Plane, err( "constructor" ))
self.assertIsInstance(Gf.Plane(Gf.Vec3d(0,0,1), Gf.Vec3d(0,1,0), Gf.Vec3d(1,0,0)), Gf.Plane,
err( "constructor" ))
self.assertIsInstance(Gf.Plane(Gf.Vec4d(3,4,0,5)), Gf.Plane, err("constructor" ))
def test_Exceptions(self):
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b'), (1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c'), (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c', 'd'), (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b'), (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c'), (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c', 'd'), (1.0, 1.0, 1.0, 1.0))
def test_Properties(self):
p = Gf.Plane()
self.assertEqual(p.Set(Gf.Vec3d(1,1,1), 1), Gf.Plane(Gf.Vec3d(1,1,1), 1), err("Set"))
self.assertEqual(p.Set(Gf.Vec3d(1,1,1), Gf.Vec3d(1,1,1)), Gf.Plane(Gf.Vec3d(1,1,1), Gf.Vec3d(1,1,1)),
err("Set"))
self.assertEqual(p.Set(Gf.Vec3d(0,0,1), Gf.Vec3d(0,1,0), Gf.Vec3d(1,0,0)),
Gf.Plane(Gf.Vec3d(0,0,1), Gf.Vec3d(0,1,0), Gf.Vec3d(1,0,0)), err("Set"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 1)
self.assertEqual(p.normal, Gf.Vec3d(1,1,1).GetNormalized(), err("normal"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 10)
self.assertEqual(p.distanceFromOrigin, 10, err("distanceFromOrigin"))
def testSkelTransforms(self):
"""
Tests that the computed joint transforms in USD, when tarnsformed into
world space, match the world space transforms of the Maya joints.
"""
mayaFile = os.path.join(self.inputPath, "UsdExportSkeletonTest", "UsdExportSkeleton.ma")
cmds.file(mayaFile, force=True, open=True)
# frameRange = [1, 30]
frameRange = [1, 3]
# TODO: The joint hierarchy intentionally includes non-joint nodes,
# which are expected to be ignored. However, when we try to extract
# restTransforms from the dagPose, the intermediate transforms cause
# problems, since they are not members of the dagPose. As a result,
# no dag pose is exported. Need to come up with a way to handle this
# correctly in export.
print("Expect warnings about invalid restTransforms")
usdFile = os.path.abspath('UsdExportSkeleton.usda')
cmds.usdExport(mergeTransformAndShape=True, file=usdFile,
shadingMode='none', frameRange=frameRange,
exportSkels='auto')
stage = Usd.Stage.Open(usdFile)
root = UsdSkel.Root.Get(stage, '/SkelChar')
self.assertTrue(root)
skelCache = UsdSkel.Cache()
if Usd.GetVersion() > (0, 20, 8):
skelCache.Populate(root, Usd.PrimDefaultPredicate)
else:
skelCache.Populate(root)
skel = UsdSkel.Skeleton.Get(stage, '/SkelChar/Hips')
self.assertTrue(skel)
skelQuery = skelCache.GetSkelQuery(skel)
self.assertTrue(skelQuery)
xfCache = UsdGeom.XformCache()
for frame in range(*frameRange):
cmds.currentTime(frame, edit=True)
xfCache.SetTime(frame)
skelLocalToWorld = xfCache.GetLocalToWorldTransform(skelQuery.GetPrim())
usdJointXforms = skelQuery.ComputeJointSkelTransforms(frame)
for joint,usdJointXf in zip(skelQuery.GetJointOrder(),
usdJointXforms):
usdJointWorldXf = usdJointXf * skelLocalToWorld
selList = OM.MSelectionList()
selList.add(Sdf.Path(joint).name)
dagPath = selList.getDagPath(0)
mayaJointWorldXf = Gf.Matrix4d(*dagPath.inclusiveMatrix())
self.assertTrue(Gf.IsClose(mayaJointWorldXf,
usdJointWorldXf, 1e-5))
def test_Methods(self):
p = Gf.Plane(Gf.Vec3d(1,1,1), 1)
self.assertTrue(Gf.IsClose(p.GetDistance(Gf.Vec3d(2,2,2)), 2.4641016151377553, 0.00001),
err("GetDistance"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 0)
self.assertTrue(Gf.IsClose(p.GetDistance(Gf.Vec3d(0,0,0)), 0, 0.00001), \
err("GetDistance"))
p = Gf.Plane(Gf.Vec3d(0,1,0), 0)
self.assertEqual(p.Project(Gf.Vec3d(3, 3, 3)), Gf.Vec3d(3, 0, 3), err("Project"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 0)
p.Transform(Gf.Matrix4d().SetRotate(Gf.Rotation(Gf.Vec3d(1,0,0), 30)))
self.assertTrue(Gf.IsClose(p.normal, Gf.Vec3d(0.57735, 0.211325, 0.788675), 0.0001))
p = Gf.Plane(Gf.Vec3d(1,1,1), 1)
self.assertEqual(p.normal * -1, p.Reorient(Gf.Vec3d()).normal, err("Reorient"))
b = Gf.Range3d()
self.assertFalse(Gf.Plane(Gf.Vec3d(1,1,1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
b = Gf.Range3d(Gf.Vec3d(-1,-1,-1), Gf.Vec3d(1,1,1))
self.assertTrue(Gf.Plane(Gf.Vec3d(1,1,1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(1,1,-1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(1,-1,1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(1,-1,-1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(-1,1,1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(-1,1,-1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(-1,-1,1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
self.assertTrue(Gf.Plane(Gf.Vec3d(-1,-1,-1), 1).IntersectsPositiveHalfSpace(b),
err("IntersectsPositiveHalfSpace"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 10)
self.assertFalse(p.IntersectsPositiveHalfSpace(Gf.Range3d(Gf.Vec3d(), Gf.Vec3d(1,1,1))),
err("IntersectsPositiveHalfSpace"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 1)
self.assertTrue(p.IntersectsPositiveHalfSpace(Gf.Vec3d(1,1,1)),
err("IntersectsPositiveHalfSpace"))
p = Gf.Plane(Gf.Vec3d(1,1,1), 10)
self.assertFalse(p.IntersectsPositiveHalfSpace(Gf.Vec3d()),
err("IntersectsPositiveHalfSpace"))
self.assertEqual(p, eval(repr(p)), err("repr"))
self.assertTrue(len(str(Gf.Plane())), err("str"))
def _MMatrixToGf(mx):
gfmx = Gf.Matrix4d()
for i in xrange(4):
for j in xrange(4):
gfmx[i][j] = mx[i * 4 + j]
return gfmx
def Test(self, cls):
def make(*vals):
return cls((vals*size)[:size])
size = len(cls())
# default ctor zero initializes
self.assertEqual(cls(), cls())
self.assertEqual([0]*size, [x for x in cls()])
# unary ctor sets all components
self.assertEqual([ToFloat(1.234)]*size, [x for x in cls(1.234)])
# explicit ctor
ctorArgs = range(123, 123 + size)
self.assertEqual([x for x in cls(*ctorArgs)], range(123, 123 + size))
# construct from vec
if size == 3:
self.assertEqual(cls(Gf.Vec3f(1,2,3)), cls(1,2,3))
elif size == 4:
self.assertEqual(cls(Gf.Vec4f(1,2,3,4)), cls(1,2,3,4))
# Clamp
self.assertEqual(make(-.5,.5,.75,1.25).Clamp(), make(0,.5,.75,1))
self.assertEqual(make(1,2,3,4).Clamp(), make(1,1,1,1))
self.assertEqual(make(1,2,3,4).Clamp(min=2), make(2,1,1,1))
self.assertEqual(make(1,2,3,4).Clamp(max=2), make(1,2,2,2))
self.assertEqual(make(1,2,3,4).Clamp(min=2,max=3), make(2,2,3,3))
# Clamp should modify in-place
x = make(1,2,3,4)
x.Clamp(2, 3)
self.assertEqual(x, make(2,2,3,3))
# IsBlack and IsWhite
self.assertTrue(make(0).IsBlack())
self.assertTrue(make(1).IsWhite())
self.assertFalse(make(1).IsBlack())
self.assertFalse(make(0).IsWhite())
self.assertFalse(make(0.5).IsBlack())
self.assertFalse(make(0.5).IsWhite())
# Transform
# XXX add test
# GetComplement
self.assertEqual(make(0).GetComplement(), make(1))
self.assertEqual(make(0, 0.25, 0.75, 1).GetComplement(), make(1, 0.75, 0.25, 0))
self.assertEqual(make(-1, 0, 1, 2).GetComplement(), make(2, 1, 0, -1))
# GetVec
# XXX add test
# GetHSV
# XXX add test
# SetHSV
# XXX add test
# r,g,b,a
# XXX add test
# repr
self.assertEqual(eval(repr(make(1,2,3,4))), make(1,2,3,4))
self.assertEqual(eval(repr(make(0))), make(0))
self.assertEqual(eval(repr(make(1))), make(1))
# str
self.assertTrue(len(str(make(0))))
self.assertTrue(len(str(make(1))))
self.assertTrue(len(str(make(1,2,3,4))))
# operators
# XXX add test
# tuples implicitly convert to rgb(a)
self.assertEqual(cls((1,)*size), make(1))
self.assertEqual(cls((0,)*size), make(0))
def testCubeWithDeformer(self):
"""
Tests that a native Maya mesh is deformed correctly by a point based
deformer node.
"""
OMA.MAnimControl.setAnimationStartEndTime(
OM.MTime(self.START_TIMECODE), OM.MTime(self.END_TIMECODE))
# Create the cube that will be affected by the deformer.
testCube = cmds.polyCube(depth=1.0, height=1.0, width=1.0)[0]
# Validate the top layer of control points of the unaffected cube.
self._ValidateControlPoint(testCube, 0, Gf.Vec3d(-0.5, -0.5, 0.5))
self._ValidateControlPoint(testCube, 1, Gf.Vec3d(0.5, -0.5, 0.5))
self._ValidateControlPoint(testCube, 2, Gf.Vec3d(-0.5, 0.5, 0.5))
self._ValidateControlPoint(testCube, 3, Gf.Vec3d(0.5, 0.5, 0.5))
# Create the USD stage node.
stageNode = cmds.createNode('pxrUsdStageNode')
cmds.setAttr('%s.filePath' % stageNode,
self._deformingCubeUsdFilePath,
type='string')
# Select the cube so that it has the deformer applied to it
# automatically when the deformer is created.
cmds.select(testCube, replace=True)
# Create the deformer and setup its attributes and connections.
deformerNode = cmds.deformer(type='pxrUsdPointBasedDeformerNode')[0]
cmds.setAttr('%s.primPath' % deformerNode,
self._deformingCubePrimPath,
type='string')
cmds.connectAttr('%s.outUsdStage' % stageNode,
'%s.inUsdStage' % deformerNode)
cmds.connectAttr('time1.outTime', '%s.time' % deformerNode)
# The Maya cube should now be driven by the USD cube, which is twice
# the size.
self._ValidateControlPoint(testCube, 0, Gf.Vec3d(-1.0, -1.0, 1.0))
self._ValidateControlPoint(testCube, 1, Gf.Vec3d(1.0, -1.0, 1.0))
self._ValidateControlPoint(testCube, 2, Gf.Vec3d(-1.0, 1.0, 1.0))
self._ValidateControlPoint(testCube, 3, Gf.Vec3d(1.0, 1.0, 1.0))
# The animated deformation on the cube should twist the top of it in
# the middle of the frame range.
cmds.currentTime(self.MID_TIMECODE)
self._ValidateControlPoint(testCube, 0, Gf.Vec3d(0.0, -1.0, 1.0))
self._ValidateControlPoint(testCube, 1, Gf.Vec3d(1.0, 0.0, 1.0))
self._ValidateControlPoint(testCube, 2, Gf.Vec3d(-1.0, 0.0, 1.0))
self._ValidateControlPoint(testCube, 3, Gf.Vec3d(0.0, 1.0, 1.0))
class testUsdExportShadingModeDisplayColor(unittest.TestCase):
RED_COLOR = 0.8 * Gf.Vec3f(1.0, 0.0, 0.0)
@classmethod
def setUpClass(cls):
standalone.initialize('usd')
mayaFile = os.path.abspath('RedCube.ma')
cmds.file(mayaFile, open=True, force=True)
# Export to USD.
usdFilePath = os.path.abspath('RedCube.usda')
cmds.loadPlugin('pxrUsd')
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
shadingMode='displayColor',
materialsScopeName='Materials')
cls._stage = Usd.Stage.Open(usdFilePath)
@classmethod
def tearDownClass(cls):
standalone.uninitialize()
def testStageOpens(self):
"""
Tests that the USD stage was opened successfully.
"""
self.assertTrue(self._stage)
def testExportDisplayColorShading(self):
"""
Tests that exporting a Maya mesh with a simple Maya shading setup
results in the correct shading on the USD mesh.
"""
# Validate the displayColor on the mesh prim.
cubePrim = self._stage.GetPrimAtPath('/RedCube/Geom/Cube')
self.assertTrue(cubePrim)
cubeMesh = UsdGeom.Mesh(cubePrim)
self.assertTrue(cubeMesh)
meshDisplayColors = cubeMesh.GetDisplayColorPrimvar().Get()
self.assertEqual(len(meshDisplayColors), 1)
self.assertTrue(
Gf.IsClose(meshDisplayColors[0],
UsdMaya.ConvertMayaToLinear(self.RED_COLOR), 1e-6))
# Validate the Material prim bound to the Mesh prim.
material = UsdShade.Material.GetBoundMaterial(cubePrim)
self.assertTrue(material)
materialPath = material.GetPath().pathString
self.assertEqual(materialPath, '/RedCube/Materials/RedLambertSG')
materialInputs = material.GetInputs()
self.assertEqual(len(materialInputs), 3)
materialInput = material.GetInput('displayColor')
matDisplayColor = materialInput.Get()
self.assertTrue(
Gf.IsClose(matDisplayColor,
UsdMaya.ConvertMayaToLinear(self.RED_COLOR), 1e-6))
# Just verify that displayOpacity and transparency exist.
materialInput = material.GetInput('displayOpacity')
self.assertTrue(materialInput)
materialInput = material.GetInput('transparency')
self.assertTrue(materialInput)
# Validate the surface shader that is connected to the material.
materialOutputs = material.GetOutputs()
self.assertEqual(len(materialOutputs), 4)
print self._stage.ExportToString()
materialOutput = material.GetOutput('ri:surface')
(connectableAPI, outputName,
outputType) = materialOutput.GetConnectedSource()
self.assertEqual(outputName, 'out')
shader = UsdShade.Shader(connectableAPI)
self.assertTrue(shader)
self.assertEqual(shader.GetPrim().GetName(), 'RedLambertSG_lambert')
shaderId = shader.GetIdAttr().Get()
self.assertEqual(shaderId, 'PxrDiffuse')
shaderInputs = shader.GetInputs()
self.assertEqual(len(shaderInputs), 2)
diffuseInput = shader.GetInput('diffuseColor')
self.assertTrue(diffuseInput)
(connectableAPI, outputName,
outputType) = diffuseInput.GetConnectedSource()
self.assertEqual(outputName, 'displayColor')
self.assertTrue(connectableAPI)
self.assertEqual(connectableAPI.GetPath().pathString, materialPath)
transmissionInput = shader.GetInput('transmissionColor')
self.assertTrue(transmissionInput)
(connectableAPI, outputName,
outputType) = transmissionInput.GetConnectedSource()
self.assertEqual(outputName, 'transparency')
self.assertTrue(connectableAPI)
self.assertEqual(connectableAPI.GetPath().pathString, materialPath)
def _GetExportedAttributesDict(doubleToSinglePrecision=False):
"""
Gets a dictionary that maps attribute name prefixes to their values
and types given the value of doubleToSinglePrecision.
"""
# To simplify testing, the Maya scene is authored so that attributes of
# similar types all have the same value, so we define those expected
# values here. We use self.assertAlmostEqual to compare the values and ensure that
# the specific Sdf.ValueTypeName of the attribute matches, so we can
# be a little sloppy with the types of these values.
BOOL_VALUE = True
INT_1_VALUE = 42
INT_2_VALUE = Gf.Vec2i(1, 2)
INT_3_VALUE = Gf.Vec3i(1, 2, 3)
ENUM_VALUE = 2 # Expect value of enum to be exported, not string
FLOAT_DOUBLE_1_VALUE = 1.1
FLOAT_DOUBLE_2_VALUE = Gf.Vec2d(1.1, 2.2)
FLOAT_DOUBLE_3_VALUE = Gf.Vec3d(1.1, 2.2, 3.3)
FLOAT_DOUBLE_4_VALUE = Gf.Vec4d(1.1, 2.2, 3.3, 4.4)
FLOAT_DOUBLE_ANGLE_VALUE = math.pi
STRING_VALUE = 'foo'
STRING_ARRAY_VALUE = ['foo', 'bar', 'baz']
FLOAT_DOUBLE_MATRIX_VALUE = Gf.Matrix4d(1.1, 1.1, 1.1, 1.0, 2.2, 2.2,
2.2, 1.0, 3.3, 3.3, 3.3, 1.0,
1.0, 1.0, 1.0, 1.0)
FLOAT_DOUBLE_ARRAY_VALUE = [1.1, 2.2, 3.3]
INT_ARRAY_VALUE = [1, 2, 3]
FLOAT_DOUBLE_VECTOR_POINT_ARRAY_VALUE = Vt.Vec3dArray([(1.1, 1.1, 1.1),
(2.2, 2.2, 2.2),
(3.3, 3.3, 3.3)
])
exportedAttrsDict = {
'myBool': {
'value': BOOL_VALUE,
'typeName': Sdf.ValueTypeNames.Bool
},
'myByte': {
'value': INT_1_VALUE,
'typeName': Sdf.ValueTypeNames.Int
},
'myChar': {
'value': INT_1_VALUE,
'typeName': Sdf.ValueTypeNames.Int
},
'myShort': {
'value': INT_1_VALUE,
'typeName': Sdf.ValueTypeNames.Int
},
'myLong': {
'value': INT_1_VALUE,
'typeName': Sdf.ValueTypeNames.Int
},
'myEnum': {
'value': ENUM_VALUE,
'typeName': Sdf.ValueTypeNames.Int
},
'myFloat': {
'value': FLOAT_DOUBLE_1_VALUE,
'typeName': Sdf.ValueTypeNames.Float
},
'myDouble': {
'value': FLOAT_DOUBLE_1_VALUE,
'typeName': Sdf.ValueTypeNames.Double
},
'myDoubleAngle': {
'value': FLOAT_DOUBLE_ANGLE_VALUE,
'typeName': Sdf.ValueTypeNames.Double
},
'myDoubleLinear': {
'value': FLOAT_DOUBLE_1_VALUE,
'typeName': Sdf.ValueTypeNames.Double
},
'myString': {
'value': STRING_VALUE,
'typeName': Sdf.ValueTypeNames.String
},
'myStringArray': {
'value': STRING_ARRAY_VALUE,
'typeName': Sdf.ValueTypeNames.StringArray
},
'myDoubleMatrix': {
'value': FLOAT_DOUBLE_MATRIX_VALUE,
'typeName': Sdf.ValueTypeNames.Matrix4d
},
'myFloatMatrix': {
'value': FLOAT_DOUBLE_MATRIX_VALUE,
'typeName': Sdf.ValueTypeNames.Matrix4d
},
'myFloat2': {
'value': FLOAT_DOUBLE_2_VALUE,
'typeName': Sdf.ValueTypeNames.Float2
},
'myFloat3': {
'value': FLOAT_DOUBLE_3_VALUE,
'typeName': Sdf.ValueTypeNames.Float3
},
'myDouble2': {
'value': FLOAT_DOUBLE_2_VALUE,
'typeName': Sdf.ValueTypeNames.Double2
},
'myDouble3': {
'value': FLOAT_DOUBLE_3_VALUE,
'typeName': Sdf.ValueTypeNames.Double3
},
'myDouble4': {
'value': FLOAT_DOUBLE_4_VALUE,
'typeName': Sdf.ValueTypeNames.Double4
},
'myLong2': {
'value': INT_2_VALUE,
'typeName': Sdf.ValueTypeNames.Int2
},
'myLong3': {
'value': INT_3_VALUE,
'typeName': Sdf.ValueTypeNames.Int3
},
'myShort2': {
'value': INT_2_VALUE,
'typeName': Sdf.ValueTypeNames.Int2
},
'myShort3': {
'value': INT_3_VALUE,
'typeName': Sdf.ValueTypeNames.Int3
},
'myDoubleArray': {
'value': FLOAT_DOUBLE_ARRAY_VALUE,
'typeName': Sdf.ValueTypeNames.DoubleArray
},
'myFloatArray': {
'value': FLOAT_DOUBLE_ARRAY_VALUE,
'typeName': Sdf.ValueTypeNames.FloatArray
},
'myIntArray': {
'value': INT_ARRAY_VALUE,
'typeName': Sdf.ValueTypeNames.IntArray
},
'myVectorArray': {
'value': FLOAT_DOUBLE_VECTOR_POINT_ARRAY_VALUE,
'typeName': Sdf.ValueTypeNames.Vector3dArray
},
'myPointArray': {
'value': FLOAT_DOUBLE_VECTOR_POINT_ARRAY_VALUE,
'typeName': Sdf.ValueTypeNames.Point3dArray
}
}
if doubleToSinglePrecision:
# Patch the dictionary with float-based types for the appropriate
# attributes.
exportedAttrsDict['myDouble'][
'typeName'] = Sdf.ValueTypeNames.Float
exportedAttrsDict['myDoubleAngle'][
'typeName'] = Sdf.ValueTypeNames.Float
exportedAttrsDict['myDoubleLinear'][
'typeName'] = Sdf.ValueTypeNames.Float
exportedAttrsDict['myDouble2'][
'typeName'] = Sdf.ValueTypeNames.Float2
exportedAttrsDict['myDouble3'][
'typeName'] = Sdf.ValueTypeNames.Float3
exportedAttrsDict['myDouble4'][
'typeName'] = Sdf.ValueTypeNames.Float4
exportedAttrsDict['myDoubleArray'][
'typeName'] = Sdf.ValueTypeNames.FloatArray
exportedAttrsDict['myVectorArray'][
'typeName'] = Sdf.ValueTypeNames.Vector3fArray
exportedAttrsDict['myPointArray'][
'typeName'] = Sdf.ValueTypeNames.Point3fArray
return exportedAttrsDict
def testExportDisplayColorShading(self):
"""
Tests that exporting a Maya mesh with a simple Maya shading setup
results in the correct shading on the USD mesh.
"""
# Validate the displayColor on the mesh prim.
cubePrim = self._stage.GetPrimAtPath('/RedCube/Geom/Cube')
self.assertTrue(cubePrim)
cubeMesh = UsdGeom.Mesh(cubePrim)
self.assertTrue(cubeMesh)
meshDisplayColors = cubeMesh.GetDisplayColorPrimvar().Get()
self.assertEqual(len(meshDisplayColors), 1)
self.assertTrue(
Gf.IsClose(meshDisplayColors[0],
UsdMaya.ConvertMayaToLinear(self.RED_COLOR), 1e-6))
# Validate the Material prim bound to the Mesh prim.
material = UsdShade.Material.GetBoundMaterial(cubePrim)
self.assertTrue(material)
materialPath = material.GetPath().pathString
self.assertEqual(materialPath, '/RedCube/Materials/RedLambertSG')
materialInputs = material.GetInputs()
self.assertEqual(len(materialInputs), 3)
materialInput = material.GetInput('displayColor')
matDisplayColor = materialInput.Get()
self.assertTrue(
Gf.IsClose(matDisplayColor,
UsdMaya.ConvertMayaToLinear(self.RED_COLOR), 1e-6))
# Just verify that displayOpacity and transparency exist.
materialInput = material.GetInput('displayOpacity')
self.assertTrue(materialInput)
materialInput = material.GetInput('transparency')
self.assertTrue(materialInput)
# Validate the surface shader that is connected to the material.
materialOutputs = material.GetOutputs()
self.assertEqual(len(materialOutputs), 4)
print self._stage.ExportToString()
materialOutput = material.GetOutput('ri:surface')
(connectableAPI, outputName,
outputType) = materialOutput.GetConnectedSource()
self.assertEqual(outputName, 'out')
shader = UsdShade.Shader(connectableAPI)
self.assertTrue(shader)
self.assertEqual(shader.GetPrim().GetName(), 'RedLambertSG_lambert')
shaderId = shader.GetIdAttr().Get()
self.assertEqual(shaderId, 'PxrDiffuse')
shaderInputs = shader.GetInputs()
self.assertEqual(len(shaderInputs), 2)
diffuseInput = shader.GetInput('diffuseColor')
self.assertTrue(diffuseInput)
(connectableAPI, outputName,
outputType) = diffuseInput.GetConnectedSource()
self.assertEqual(outputName, 'displayColor')
self.assertTrue(connectableAPI)
self.assertEqual(connectableAPI.GetPath().pathString, materialPath)
transmissionInput = shader.GetInput('transmissionColor')
self.assertTrue(transmissionInput)
(connectableAPI, outputName,
outputType) = transmissionInput.GetConnectedSource()
self.assertEqual(outputName, 'transparency')
self.assertTrue(connectableAPI)
self.assertEqual(connectableAPI.GetPath().pathString, materialPath)
def _ValidatePxrEnvDayLight(self):
nodePath = '|RfMLightsTest|Lights|EnvDayLight|EnvDayLightShape'
expectedDay = 9
self.assertEqual(cmds.getAttr('%s.day' % nodePath), expectedDay)
expectedHaziness = 1.9
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.haziness' % nodePath),
expectedHaziness, 1e-6))
expectedHour = 9.9
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.hour' % nodePath),
expectedHour, 1e-6))
expectedLatitude = 90.0
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.latitude' % nodePath),
expectedLatitude, 1e-6))
expectedLongitude = -90.0
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.longitude' % nodePath),
expectedLongitude, 1e-6))
expectedMonth = 9
self.assertEqual(cmds.getAttr('%s.month' % nodePath), expectedMonth)
expectedSkyTint = Gf.Vec3f(0.9)
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.skyTintR' % nodePath),
expectedSkyTint[0], 1e-6))
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.skyTintG' % nodePath),
expectedSkyTint[1], 1e-6))
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.skyTintB' % nodePath),
expectedSkyTint[2], 1e-6))
expectedSunDirection = Gf.Vec3f(0.0, 0.0, 0.9)
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunDirectionX' % nodePath),
expectedSunDirection[0], 1e-6))
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunDirectionY' % nodePath),
expectedSunDirection[1], 1e-6))
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunDirectionZ' % nodePath),
expectedSunDirection[2], 1e-6))
expectedSunSize = 0.9
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunSize' % nodePath),
expectedSunSize, 1e-6))
expectedSunTint = Gf.Vec3f(0.9)
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunTintR' % nodePath),
expectedSunTint[0], 1e-6))
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunTintG' % nodePath),
expectedSunTint[1], 1e-6))
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.sunTintB' % nodePath),
expectedSunTint[2], 1e-6))
expectedYear = 2019
self.assertEqual(cmds.getAttr('%s.year' % nodePath), expectedYear)
expectedZone = 9.0
self.assertTrue(Gf.IsClose(cmds.getAttr('%s.zone' % nodePath),
expectedZone, 1e-6))
def test_EmptyFrustumIntersection(self):
self.assertFalse(Gf.Frustum().Intersects(Gf.BBox3d()))
self.assertTrue(Gf.Frustum().Intersects(
Gf.BBox3d(Gf.Range3d(Gf.Vec3d(-1, -1, -1), Gf.Vec3d(1, 1, 1)))))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(0, 0, -1)))
self.assertFalse(Gf.Frustum().Intersects(Gf.Vec3d(0, 0, 0)))
self.assertFalse(Gf.Frustum().Intersects(Gf.Vec3d(), Gf.Vec3d(1, 1, 1),
Gf.Vec3d(0, 0, 1)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(),
Gf.Vec3d(-1, -1, -1),
Gf.Vec3d(0, 0, 1)))
self.assertFalse(Gf.Frustum().Intersects(Gf.Vec3d(0, 100, -100), \
Gf.Vec3d(-100,-100,100), \
Gf.Vec3d(100,-100,100)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(0, 10, 100), \
Gf.Vec3d(-100,-10,-10), \
Gf.Vec3d(100,-10,-10)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(0, 1, 1), \
Gf.Vec3d(50,0,-50), \
Gf.Vec3d(-50,0,-50)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(),
Gf.Vec3d(-1, -1, -1),
Gf.Vec3d(0, 0, 1)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(0, 0, 0),
Gf.Vec3d(1, 1, -1)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(-100, 0, -1),
Gf.Vec3d(100, 0, -1)))
self.assertTrue(Gf.Frustum().Intersects(Gf.Vec3d(0, 100, -1),
Gf.Vec3d(0, -100, -1)))
self.assertFalse(Gf.Frustum().Intersects(Gf.Vec3d(-100, 0, 1),
Gf.Vec3d(100, 0, -1)))
self.assertFalse(Gf.Frustum().Intersects(Gf.Vec3d(0, 0, 0),
Gf.Vec3d(1, 1, 1)))
