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