def test_ClipTimingOutsideRange(self): """Tests clip retiming behavior when the mapped clip times are outside the range of time samples in the clip""" stage = Usd.Stage.Open('timingOutsideClip/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) model = stage.GetPrimAtPath('/Model') attr = model.GetAttribute('size') # This test case maps frames [0, 10] on the stage to [30, 40] on # the clip. However, the clip only has time samples on frames [5, 25]. # The expected behavior is to clamp to the nearest clip time sample, # which is on frame 25 in the clip. for t in xrange(11): _Check(self.assertEqual, attr, time=t, expected=25.0) self.assertEqual(attr.GetBracketingTimeSamples(t), (0.0, 0.0)) # Asking for frames outside the mapped times should also clamp to # the nearest time sample. for t in xrange(-10, 0): _Check(self.assertEqual, attr, time=t, expected=25.0) self.assertEqual(attr.GetBracketingTimeSamples(t), (0.0, 0.0)) for t in xrange(11, 20): _Check(self.assertEqual, attr, time=t, expected=25.0) self.assertEqual(attr.GetBracketingTimeSamples(t), (0.0, 0.0)) self.assertEqual(attr.GetTimeSamples(), [0.0]) self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(-1.0, 1.0)), [0.0]) self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0.0, 0.0)), [0.0]) ValidateAttributeTimeSamples(attr)
def test_OverrideOfAncestralClips(self): """Tests that clips specified on a descendant model will override clips specified on an ancestral model""" stage = Usd.Stage.Open('ancestral/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) ancestor = stage.GetPrimAtPath('/ModelGroup') ancestorAttr = ancestor.GetAttribute('attr') self.assertEqual(ancestorAttr.GetTimeSamples(), [5, 10, 15]) self.assertEqual( ancestorAttr.GetTimeSamplesInInterval(Gf.Interval(0, 15)), [5, 10, 15]) _Check(self.assertEqual, ancestorAttr, time=5, expected=-5) _Check(self.assertEqual, ancestorAttr, time=10, expected=-10) _Check(self.assertEqual, ancestorAttr, time=15, expected=-15) descendant = stage.GetPrimAtPath('/ModelGroup/Model') descendantAttr = descendant.GetAttribute('attr') self.assertEqual(descendantAttr.GetTimeSamples(), [1, 2, 3]) self.assertEqual( descendantAttr.GetTimeSamplesInInterval(Gf.Interval(0, 2.95)), [1, 2]) _Check(self.assertEqual, descendantAttr, time=1, expected=-1) _Check(self.assertEqual, descendantAttr, time=2, expected=-2) _Check(self.assertEqual, descendantAttr, time=3, expected=-3) ValidateAttributeTimeSamples(ancestorAttr) ValidateAttributeTimeSamples(descendantAttr)
def test_GetUnionedTimeSamples(self): s = Usd.Stage.CreateInMemory() foo = s.DefinePrim('/foo') attr1 = foo.CreateAttribute('attr1', Sdf.ValueTypeNames.Bool) self.assertEqual([], attr1.GetTimeSamples()) attr1.Set(True, 1.0) attr1.Set(False, 3.0) attr2 = foo.CreateAttribute('attr2', Sdf.ValueTypeNames.Float) attr2.Set(100.0, 2.0) attr2.Set(200.0, 4.0) self.assertEqual(Usd.Attribute.GetUnionedTimeSamples([attr1, attr2]), [1.0, 2.0, 3.0, 4.0]) self.assertEqual( Usd.Attribute.GetUnionedTimeSamplesInInterval([attr1, attr2], Gf.Interval( 1.5, 3.5)), [2.0, 3.0]) attrQueries = [Usd.AttributeQuery(attr1), Usd.AttributeQuery(attr2)] self.assertEqual(Usd.AttributeQuery.GetUnionedTimeSamples(attrQueries), [1.0, 2.0, 3.0, 4.0]) self.assertEqual( Usd.AttributeQuery.GetUnionedTimeSamplesInInterval( attrQueries, Gf.Interval(1.5, 3.5)), [2.0, 3.0])
def test_ClipsWithLayerOffsets(self): """Tests behavior of clips when layer offsets are involved""" stage = Usd.Stage.Open('layerOffsets/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) model1 = stage.GetPrimAtPath('/Model_1') attr1 = model1.GetAttribute('size') # Default value should be unaffected by layer offsets. _Check(self.assertEqual, attr1, expected=1.0) # The clip should be active starting from frame -10.0 due to the # offset; outside of that we should get the value from the reference. _Check(self.assertEqual, attr1, time=-11, expected=-5.0) # Sublayer offset of 10 frames is present, so attribute value at # frame 0 should be from the clip at frame 10, etc. _Check(self.assertEqual, attr1, time=0, expected=-10.0) _Check(self.assertEqual, attr1, time=-5, expected=-5.0) _Check(self.assertEqual, attr1, time=-10, expected=-5.0) self.assertEqual(attr1.GetTimeSamples(), [-5, 0, 5, 10]) self.assertEqual(attr1.GetTimeSamplesInInterval(Gf.Interval(-10, 10)), [-5, 0, 5, 10]) # Test that layer offsets on layers where clipTimes/clipActive are # authored are taken into account. The test case is similar to above, # except clipTimes/clipActive have been authored in a sublayer that # is offset by 20 frames instead of 10. model2 = stage.GetPrimAtPath('/Model_2') attr2 = model2.GetAttribute('size') _Check(self.assertEqual, attr2, expected=1.0) _Check(self.assertEqual, attr2, time=-21, expected=-5.0) _Check(self.assertEqual, attr2, time=0, expected=-20.0) _Check(self.assertEqual, attr2, time=-5, expected=-15.0) _Check(self.assertEqual, attr2, time=-10, expected=-10.0) self.assertEqual(attr2.GetTimeSamples(), [-15, -10, -5, 0]) self.assertEqual(attr2.GetTimeSamplesInInterval(Gf.Interval(-3, 1)), [0]) # Test that reference offsets are taken into account. An offset # of 10 frames is authored on the reference; this should be combined # with the offset of 10 frames on the sublayer. model3 = stage.GetPrimAtPath('/Model_3') attr3 = model3.GetAttribute('size') _Check(self.assertEqual, attr3, expected=1.0) _Check(self.assertEqual, attr3, time=-21, expected=-5.0) _Check(self.assertEqual, attr3, time=0, expected=-20.0) _Check(self.assertEqual, attr3, time=-5, expected=-15.0) _Check(self.assertEqual, attr3, time=-10, expected=-10.0) self.assertEqual(attr3.GetTimeSamples(), [-15, -10, -5, 0]) self.assertEqual(attr3.GetTimeSamplesInInterval(Gf.Interval(-5, 5)), [-5, 0]) ValidateAttributeTimeSamples(attr1) ValidateAttributeTimeSamples(attr2) ValidateAttributeTimeSamples(attr3)
def test_TimeSamplesWithOffset(self): ''' Test the effect of SdfLayerOffset on timesample API. ''' stage = Usd.Stage.CreateInMemory() # Set up a simple prim </Source> # with an attribute 'x' with a simple linear ramp over frames 0..10. source = stage.DefinePrim('/Source') source_attr = source.CreateAttribute('x', Sdf.ValueTypeNames.Float) source_attr.Set(0.0, 0.0) source_attr.Set(10.0, 10.0) self.assertEqual(source_attr.GetTimeSamples(), [0.0, 10.0]) self.assertEqual(source_attr.Get(0.0), 0) self.assertEqual(source_attr.Get(10.0), 10) # Reference that prim, with an offset of +100 frames. test1 = stage.DefinePrim('/Test1') test1.GetReferences().AddInternalReference( '/Source', Sdf.LayerOffset(offset=100.0, scale=1.0)) test1_attr = test1.GetAttribute('x') # Both samples should pass through. # The sample times should be offset. self.assertEqual(test1_attr.GetTimeSamples(), [100.0, 110.0]) self.assertEqual( test1_attr.GetTimeSamplesInInterval(Gf.Interval(0, 10)), []) self.assertEqual( test1_attr.GetTimeSamplesInInterval(Gf.Interval(0, 110)), [100.0, 110.0]) # Value resolution should respect the offset. # Times outside the interval hold at the value of the nearest sample. self.assertEqual(test1_attr.Get(0.0), 0) self.assertEqual(test1_attr.Get(10.0), 0) self.assertEqual(test1_attr.Get(100.0), 0) self.assertEqual(test1_attr.Get(110.0), 10) self.assertEqual(test1_attr.Get(120.0), 10) # Reference that prim, with a 2x scale. test2 = stage.DefinePrim('/Test2') test2.GetReferences().AddInternalReference( '/Source', Sdf.LayerOffset(offset=0.0, scale=2.0)) test2_attr = test2.GetAttribute('x') # Both samples should pass through. # The sample times should be offset. self.assertEqual(test2_attr.GetTimeSamples(), [0.0, 20.0]) self.assertEqual( test2_attr.GetTimeSamplesInInterval(Gf.Interval(0, 10)), [0.0]) self.assertEqual( test2_attr.GetTimeSamplesInInterval(Gf.Interval(0, 20)), [0.0, 20.0]) # Value resolution should respect the offset. # Times outside the interval hold at the value of the nearest sample. self.assertEqual(test2_attr.Get(0.0), 0) self.assertEqual(test2_attr.Get(10.0), 5) self.assertEqual(test2_attr.Get(20.0), 10) self.assertEqual(test2_attr.Get(30.0), 10)
def test_ClipTiming(self): """Exercises clip retiming via clipTimes metadata""" stage = Usd.Stage.Open('timing/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) model = stage.GetPrimAtPath('/Model') attr = model.GetAttribute('size') # Default value should come through regardless of clip timing. _Check(self.assertEqual, attr, expected=1.0) # The 'clipTimes' metadata authored in the test asset offsets the # time samples in the clip by 10 frames and scales it slower by 50%, # repeating at frame 21. _Check(self.assertEqual, attr, time=0, expected=10.0) _Check(self.assertEqual, attr, time=5, expected=10.0) _Check(self.assertEqual, attr, time=10, expected=15.0) _Check(self.assertEqual, attr, time=15, expected=15.0) _Check(self.assertEqual, attr, time=20, expected=20.0) _Check(self.assertEqual, attr, time=21, expected=10.0) _Check(self.assertEqual, attr, time=26, expected=10.0) _Check(self.assertEqual, attr, time=31, expected=15.0) _Check(self.assertEqual, attr, time=36, expected=15.0) _Check(self.assertEqual, attr, time=41, expected=20.0) # Requests for samples before and after the mapping specified in # 'clipTimes' just pick up the first or last time sample. _Check(self.assertEqual, attr, time=-1, expected=10.0) _Check(self.assertEqual, attr, time=42, expected=20.0) # The clip has time samples authored every 5 frames, but # since we've scaled everything by 50%, we should have samples # every 10 frames. self.assertEqual(attr.GetTimeSamples(), [0, 10, 20, 21, 31, 41]) self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0, 30)), [0, 10, 20, 21]) # Test trickier cases where time samples in the clip fall outside # of the time domain specified by the 'clipTimes' metadata. model2 = stage.GetPrimAtPath('/Model2') attr2 = model2.GetAttribute('size') _Check(self.assertEqual, attr2, time=0, expected=15.0) _Check(self.assertEqual, attr2, time=20, expected=15.0) _Check(self.assertEqual, attr2, time=30, expected=25.0) self.assertEqual(attr2.GetTimeSamples(), [10, 25]) self.assertEqual(attr2.GetTimeSamplesInInterval(Gf.Interval(0, 25)), [10, 25]) ValidateAttributeTimeSamples(attr) ValidateAttributeTimeSamples(attr2)
def test_MultipleClipsWithSomeTimeSamples(self): """Tests behavior when multiple clips are specified on a prim and some of them have samples for an attribute owned by that prim, while others do not.""" stage = Usd.Stage.Open('multiclip/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) model = stage.GetPrimAtPath('/ModelWithSomeClipSamples') attr = model.GetAttribute('size') # The clip in the range [..., 16) has no samples for the attribute, # so the value should be the default value from the reference. for t in xrange(-10, 16): _Check(self.assertEqual, attr, time=t, expected=1.0) # This attribute should be detected as potentially time-varying # since multiple clips are involved and at least one of them has # samples. self.assertTrue(attr.ValueMightBeTimeVarying()) # The clip in the range [16, ...) has samples on frames 3, 6, 9 so # we expect time samples for this attribute at frames 19, 22, and 25. for t in xrange(16, 22): _Check(self.assertEqual, attr, time=t, expected=-23.0) for t in xrange(22, 25): _Check(self.assertEqual, attr, time=t, expected=-26.0) for t in xrange(25, 31): _Check(self.assertEqual, attr, time=t, expected=-29.0) self.assertEqual(attr.GetTimeSamples(), [16.0, 19.0, 22.0, 25.0]) self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(-5, 50)), [16.0, 19.0, 22.0, 25.0]) ValidateAttributeTimeSamples(attr)
def test_LinearBlendSkinningWithInterval(self): testFile = "lbs.usda" stage = Usd.Stage.Open(testFile) self.assertTrue(UsdSkel.BakeSkinning( stage.Traverse(), Gf.Interval(1, 10))) stage.GetRootLayer().Export("lbs.bakedInterval.usda")
def test_GetTimeSamples(self): s = Usd.Stage.CreateInMemory() x = UsdGeom.Xform.Define(s, '/World') xlateOp = x.AddTranslateOp() scaleOp = x.AddScaleOp() self.assertEqual([], xlateOp.GetTimeSamples()) self.assertEqual([], scaleOp.GetTimeSamples()) xlate1 = Gf.Vec3d(10., 20., 30.) scale2 = Gf.Vec3f(1., 2., 3.) xlate3 = Gf.Vec3d(10., 20., 30.) scale4 = Gf.Vec3f(1., 2., 3.) self.assertEqual(x.GetTimeSamples(), []) xlateOp.Set(xlate1, Usd.TimeCode(1)) self.assertEqual(x.GetTimeSamples(), [1.0]) xlateOp.Set(xlate3, Usd.TimeCode(3)) self.assertEqual(x.GetTimeSamples(), [1.0, 3.0]) scaleOp.Set(scale2, Usd.TimeCode(2)) self.assertEqual(x.GetTimeSamples(), [1.0, 2.0, 3.0]) scaleOp.Set(scale4, Usd.TimeCode(4)) self.assertEqual(x.GetTimeSamples(), [1.0, 2.0, 3.0, 4.0]) self.assertEqual([1.0, 3.0], xlateOp.GetTimeSamples()) self.assertEqual([2.0, 4.0], scaleOp.GetTimeSamples()) self.assertEqual([3.0], xlateOp.GetTimeSamplesInInterval(Gf.Interval(2, 4))) self.assertEqual([2.0], scaleOp.GetTimeSamplesInInterval(Gf.Interval(0, 3))) self.assertEqual(x.GetTimeSamplesInInterval(Gf.Interval(1.5, 3.2)), [2.0, 3.0])
def test_ClipTimesBracketingTimeSamplePrecision(self): stage = Usd.Stage.Open('precision/root.usda') prim = stage.GetPrimAtPath('/World/fx/Particles_Splash/points') attr = prim.GetAttribute('points') self.assertEqual(attr.GetTimeSamples(), [101.0, 101.99, 102.0, 103.0]) self.assertEqual(attr.GetBracketingTimeSamples(101), (101.00, 101.00)) self.assertEqual(attr.GetBracketingTimeSamples(101.99), (101.99, 101.99)) self.assertEqual(attr.GetBracketingTimeSamples(101.90), (101.00, 101.99)) self.assertEqual( attr.GetTimeSamplesInInterval(Gf.Interval(101.0, 102.0)), [101.00, 101.99, 102.00])
def test_MultipleClipsWithSomeTimeSamples2(self): """Another test case similar to TestMultipleClipsWithSomeTimeSamples2.""" stage = Usd.Stage.Open('multiclip/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) model = stage.GetPrimAtPath('/ModelWithSomeClipSamples2') attr = model.GetAttribute('size') # This attribute should be detected as potentially time-varying # since multiple clips are involved and at least one of them has # samples. self.assertTrue(attr.ValueMightBeTimeVarying()) # Clips are active in the range [..., 4.0), [4.0, 8.0), and [8.0, ...). # The first and last clips have time samples for the size attribute, # while the middle clip does not. # First clip. _Check(self.assertEqual, attr, time=-1, expected=-23.0) _Check(self.assertEqual, attr, time=0, expected=-23.0) _Check(self.assertEqual, attr, time=1, expected=-23.0) _Check(self.assertEqual, attr, time=2, expected=-23.0) _Check(self.assertEqual, attr, time=3, expected=-26.0) # Middle clip with no samples. Since the middle clip has no time samples, # we get the default value specified in the reference, since that's next # in the value resolution order. _Check(self.assertEqual, attr, time=4, expected=1.0) _Check(self.assertEqual, attr, time=5, expected=1.0) _Check(self.assertEqual, attr, time=6, expected=1.0) _Check(self.assertEqual, attr, time=7, expected=1.0) # Last clip. _Check(self.assertEqual, attr, time=8, expected=-26.0) _Check(self.assertEqual, attr, time=9, expected=-26.0) _Check(self.assertEqual, attr, time=10, expected=-26.0) _Check(self.assertEqual, attr, time=11, expected=-29.0) _Check(self.assertEqual, attr, time=12, expected=-29.0) self.assertEqual(attr.GetTimeSamples(), [0.0, 3.0, 4.0, 8.0, 11.0]) self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0, 10)), [0.0, 3.0, 4.0, 8.0]) ValidateAttributeTimeSamples(attr)
def ValidateAttributeTimeSamples(attr): """Verifies attribute time samples are as expected via the time sample API""" allTimeSamples = attr.GetTimeSamples() assert attr.GetNumTimeSamples() == len(allTimeSamples) for i in range(0, len(allTimeSamples) - 1): (lowerSample, upperSample) = \ (int(allTimeSamples[i]), int(allTimeSamples[i+1])) # The attribute's bracketing time samples at each time returned # by GetTimeSamples() should be equal to the time. assert attr.GetBracketingTimeSamples(lowerSample) == \ (lowerSample, lowerSample) assert attr.GetBracketingTimeSamples(upperSample) == \ (upperSample, upperSample) # The attribute's bracketing time samples should be the same # at every time in the interval (lowerSample, upperSample) for t in range(lowerSample + 1, upperSample - 1): assert attr.GetBracketingTimeSamples(t) == (lowerSample, upperSample) # The attribute should return the same value at every time in the # interval [lowerSample, upperSample) for t in range(lowerSample, upperSample - 1): assert attr.Get(t) == attr.Get(lowerSample) # Verify that getting the complete time sample map for this # attribute is equivalent to asking for the value at each time # returned by GetTimeSamples() timeSampleMap = dict([(t, attr.Get(t)) for t in allTimeSamples]) assert timeSampleMap == attr.GetMetadata('timeSamples') # Verify that getting ranges of time samples works if len(allTimeSamples) > 2: startClip = min(allTimeSamples) endClip = startClip while endClip < max(allTimeSamples): assert attr.GetTimeSamplesInInterval(Gf.Interval(startClip, endClip)) == \ [t for t in allTimeSamples if t <= endClip] endClip += 1
def test_MultipleClips(self): """Verifies behavior with multiple clips being applied to a single prim""" stage = Usd.Stage.Open('multiclip/root.usda') stage.SetInterpolationType(Usd.InterpolationTypeHeld) model = stage.GetPrimAtPath('/Model_1') attr = model.GetAttribute('size') # This prim has multiple clips that contribute values to this attribute, # so it should be detected as potentially time varying. self.assertTrue(attr.ValueMightBeTimeVarying()) # Doing this check should only have caused the first clip to be opened. self.assertTrue(Sdf.Layer.Find('multiclip/clip1.usda')) self.assertFalse(Sdf.Layer.Find('multiclip/clip2.usda')) # clip1 is active in the range [..., 16) # clip2 is active in the range [16, ...) # Check that we get time samples from the right clip when querying # in those ranges. _Check(self.assertEqual, attr, time=5, expected=-5) _Check(self.assertEqual, attr, time=10, expected=-10) _Check(self.assertEqual, attr, time=15, expected=-15) _Check(self.assertEqual, attr, time=19, expected=-23) _Check(self.assertEqual, attr, time=22, expected=-26) _Check(self.assertEqual, attr, time=25, expected=-29) # Value clips introduce time samples at their boundaries, even if there # isn't an actual time sample in the clip at that time. This is to # isolate them from surrounding clips. So, the value from frame 16 comes # from clip 2. _Check(self.assertEqual, attr, time=16, expected=-23) self.assertEqual(attr.GetBracketingTimeSamples(16), (16, 16)) # Verify that GetTimeSamples() returns time samples from both clips. self.assertEqual(attr.GetTimeSamples(), [5, 10, 15, 16, 19, 22, 25]) self.assertEqual(attr.GetTimeSamplesInInterval(Gf.Interval(0, 30)), [5, 10, 15, 16, 19, 22, 25]) ValidateAttributeTimeSamples(attr)
def set_timesamples_for_prim(prim, start, end): min_sample = None max_sample = None for attr in prim.GetAuthoredAttributes(): time_samples = attr.GetTimeSamplesInInterval(Gf.Interval(start, end)) if len(time_samples) > 0: nearest_min_sample = min(time_samples, key=lambda x: abs(x - start)) nearest_max_sample = min(time_samples, key=lambda x: abs(x - end)) if end > start: value = {sample: attr.Get(sample) for sample in time_samples} else: value = attr.Get(nearest_min_sample) attr.Clear() if isinstance(value, dict): for sample, val in value.items(): attr.Set(val, sample) else: attr.Set(value) if not min_sample: min_sample = nearest_min_sample else: if nearest_min_sample < min_sample: min_sample = nearest_min_sample if not max_sample: max_sample = nearest_max_sample else: if nearest_max_sample > max_sample: max_sample = nearest_max_sample else: if value := attr.Get(0): attr.Clear() attr.Set(value)
def test_PrimvarAPI(self): # We'll put all our Primvar on a single mesh gprim stage = Usd.Stage.CreateInMemory('myTest.usda') gp = UsdGeom.Mesh.Define(stage, '/myMesh') nPasses = 3 # Add three Primvars u1 = gp.CreatePrimvar('u_1', Sdf.ValueTypeNames.FloatArray) # Make sure it's OK to manually specify the classifier namespace v1 = gp.CreatePrimvar('primvars:v_1', Sdf.ValueTypeNames.FloatArray) _3dpmats = gp.CreatePrimvar('projMats', Sdf.ValueTypeNames.Matrix4dArray, "constant", nPasses) # ensure we can't create a primvar that contains namespaces. with self.assertRaises(Tf.ErrorException): gp.CreatePrimvar('no:can:do', Sdf.ValueTypeNames.FloatArray) self.assertEqual(len(gp.GetAuthoredPrimvars()), 3) self.assertEqual(len(gp.GetPrimvars()), 5) # Now add some random properties, and reverify p = gp.GetPrim() p.CreateRelationship("myBinding") p.CreateAttribute("myColor", Sdf.ValueTypeNames.Color3f) p.CreateAttribute("primvars:my:overly:namespaced:Color", Sdf.ValueTypeNames.Color3f) datas = gp.GetAuthoredPrimvars() IsPrimvar = UsdGeom.Primvar.IsPrimvar self.assertEqual(len(datas), 3) 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.HasPrimvar('u_1')) self.assertTrue(gp.HasPrimvar('v_1')) self.assertTrue(gp.HasPrimvar('projMats')) self.assertFalse(gp.HasPrimvar('myColor')) self.assertFalse(gp.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[1].GetTypeName(), Sdf.ValueTypeNames.FloatArray) self.assertEqual(datas[2].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.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.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()) 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([]) self.assertTrue(u1.SetIndices(indicesAt1, 1.0)) self.assertEqual(u1.GetIndices(1.0), indicesAt1) uValAt1 = Vt.FloatArray([2.1, 3.1, 4.1]) 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) uValAt2 = Vt.FloatArray([3.1, 4.1, 5.1]) 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()) 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.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.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.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) # Id primvar notId = gp.CreatePrimvar('notId', Sdf.ValueTypeNames.FloatArray) self.assertFalse(notId.IsIdTarget()) with self.assertRaises(Tf.ErrorException): notId.SetIdTarget(gp.GetPath()) handleid = gp.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.GetPrimvars()) # This check below ensures that the "indices" attributes belonging to # indexed primvars aren't considered to be primvars themselves. self.assertEqual(numPrimvars, 7) 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.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.CreatePrimvar('handleid_array', Sdf.ValueTypeNames.StringArray) self.assertTrue(handleid_array.SetIdTarget(gp.GetPath()))
def runTest(self): # Test utility functions self.assertEqual(list(subsets([1,2,3])), [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]) self.assertEqual(list(permute([1,2,3])), [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]) intervals = [Gf.Interval( ), Gf.Interval(-2, -1), Gf.Interval( 1 ), Gf.Interval( 2, 5), Gf.Interval( 3, 4), Gf.Interval( 5, 7), Gf.Interval( 6, 8)] testSets = list(map(Gf.MultiInterval, intervals)) # Test empty multi-intervals self.assertEqual(Gf.MultiInterval(), Gf.MultiInterval()) self.assertEqual(Gf.MultiInterval(), Gf.MultiInterval( Gf.Interval() )) self.assertNotEqual(Gf.MultiInterval(), Gf.MultiInterval( Gf.Interval(1) )) # Test == and != for i in range(len(testSets)): for j in range(i, len(testSets)): self.assertEqual((i==j), (testSets[i]==testSets[j])) self.assertEqual((i!=j), (testSets[i]!=testSets[j])) # Test repr and copy ctor for s in testSets: self.assertEqual(eval(repr(s)), s) self.assertEqual(Gf.MultiInterval(s), s) # Test that Add()ing intervals in any order yields same result expected = None for p in permute(intervals): x = Gf.MultiInterval() for i in p: x.Add(i) if expected is None: expected = x else: self.assertEqual(expected, x) # Track unique multi-intervals that we synthesize uniqueSets = set() num = 7 # Test Add() for s in subsets(range(num)): for p in permute(s): x = Gf.MultiInterval() for i in p: x.Add( Gf.Interval(i, i+1.0, True, False) ) # Verify for i in range(num): if i in p: # Should have been added self.assertTrue(x.Contains(i+0.5)) else: # Should not have been added self.assertFalse(x.Contains(i+0.5)) # Accumulate unique multi-intervals we construct uniqueSets.add(x) # We expect 2**num unique sets, corresponding to the power-set of range(num). self.assertEqual(len(uniqueSets), 2**num) # Test Remove() for s in subsets(range(num)): for p in permute(s): x = Gf.MultiInterval( Gf.Interval(0, num) ) for i in p: x.Remove( Gf.Interval(i, i+1.0) ) # Verify for i in range(num): if i in p: # Should have been removed self.assertFalse(x.Contains(i+0.5)) else: # Should have been retained self.assertTrue(x.Contains(i+0.5)) #Test add optimizing the interval merging for open and closed intervals num = 5 for r in range(num): # Testing only on at least two intervals s = r + 2 for p in permute(list(range(s))): # Adding range of [i, i+1) intervals should leave one interval in the set x = Gf.MultiInterval() for i in p: x.Add( Gf.Interval(i, i+1.0, True, False) ) print(x) self.assertEqual(x.bounds, Gf.Interval(0, s, True, False)) self.assertTrue(x.Contains(Gf.Interval(0, s, True, False))) self.assertFalse(x.Contains(Gf.Interval(0, s, True, True))) self.assertEqual(x.size, 1) # Adding range of (i, i+1] intervals should leave one interval in the set x = Gf.MultiInterval() for i in p: x.Add( Gf.Interval(i, i+1.0, False, True) ) print(x) self.assertEqual(x.bounds, Gf.Interval(0, s, False, True)) self.assertTrue(x.Contains(Gf.Interval(0, s, False, True))) self.assertFalse(x.Contains(Gf.Interval(0, s, True, True))) self.assertEqual(x.size, 1) # Adding range of [i, i+1] intervals should leave one interval in the set x = Gf.MultiInterval() for i in p: x.Add( Gf.Interval(i, i+1.0, True, True) ) print(x) self.assertEqual(x.bounds, Gf.Interval(0, s, True, True)) self.assertTrue(x.Contains(Gf.Interval(0, s, True, True))) self.assertEqual(x.size, 1) # Adding range of (i, i+1) intervals should leave the size of range # number of open intervals in the set x = Gf.MultiInterval() for i in p: x.Add( Gf.Interval(i, i+1.0, False, False) ) print(x) self.assertEqual(x.bounds, Gf.Interval(0, s, False, False)) self.assertFalse(x.Contains(Gf.Interval(0, s, False, False))) self.assertEqual(x.size, s) # Test Remove() edge cases a = Gf.Interval( 0, 1, True, False ) b = Gf.Interval( 0, 1, False, False ) s = Gf.MultiInterval(a) s.Remove(b) self.assertEqual(s, Gf.MultiInterval( Gf.Interval(0,0) )) a = Gf.Interval( 0, 1, True, True ) b = Gf.Interval( 0, 1, False, False ) s = Gf.MultiInterval(a) s.Remove(b) self.assertEqual(s, Gf.MultiInterval( [Gf.Interval(0,0), Gf.Interval(1,1)] )) s = Gf.MultiInterval( [Gf.Interval(0,1), Gf.Interval(3,4)] ) a = Gf.Interval( 0, 4, False, False ) s.Remove(a) self.assertEqual(s, Gf.MultiInterval( [Gf.Interval(0,0), Gf.Interval(4,4)] ) ) # Test GetComplement() for s in testSets: self.assertNotEqual(s.GetComplement(), s) self.assertEqual(s.GetComplement().GetComplement(), s) # Test that GetComplement() for empty multi-interval is the multi-interval # containing the full interval. s = Gf.MultiInterval() self.assertEqual(s.GetComplement(), Gf.MultiInterval(Gf.Interval.GetFullInterval())) self.assertEqual(s.GetComplement().GetComplement(), s) # Test Contains() with double values s = Gf.MultiInterval( [Gf.Interval(1,2), Gf.Interval(3,4)] ) self.assertFalse(s.Contains(0.99)) self.assertTrue(s.Contains(1.00)) self.assertTrue(s.Contains(1.01)) self.assertTrue(s.Contains(1.99)) self.assertTrue(s.Contains(2.00)) self.assertFalse(s.Contains(2.01)) self.assertFalse(s.Contains(2.99)) self.assertTrue(s.Contains(3.00)) self.assertTrue(s.Contains(3.01)) self.assertTrue(s.Contains(3.99)) self.assertTrue(s.Contains(4.00)) self.assertFalse(s.Contains(4.01)) # Test Contains() with intervals self.assertFalse(s.Contains( Gf.Interval() )) self.assertFalse(s.Contains( Gf.Interval(0.99, 2) )) # closed but larger self.assertTrue(s.Contains( Gf.Interval(1, 2, False, True) )) # half-open self.assertTrue(s.Contains( Gf.Interval(1, 2, True, False) )) # half-open self.assertTrue(s.Contains( Gf.Interval(1, 2, True, True) )) # totally contained # Test Contains() with multi-intervals self.assertFalse(s.Contains( Gf.MultiInterval() )) self.assertTrue(s.Contains( s )) self.assertTrue(s.Contains( Gf.MultiInterval( [Gf.Interval(1,2)] ) )) self.assertTrue(s.Contains( Gf.MultiInterval( [Gf.Interval(3,4)] ) )) self.assertTrue(s.Contains( Gf.MultiInterval( [Gf.Interval(1,1.3), Gf.Interval(1.6,2)] ) )) self.assertFalse(s.Contains( Gf.MultiInterval( [Gf.Interval(1,4)] ) )) self.assertFalse(s.Contains( Gf.MultiInterval( [Gf.Interval(1,2), Gf.Interval(3,5)] ) )) self.assertFalse(s.Contains( Gf.MultiInterval( [Gf.Interval(1,2), Gf.Interval(3,4), Gf.Interval(5,6)] ) )) # Test iterator multiInterval = Gf.MultiInterval( [Gf.Interval( 2, 4), Gf.Interval(-1, 3), Gf.Interval( 6, 7)]) intervals = [ Gf.Interval(-1, 4), Gf.Interval( 6, 7) ] number = 0 for m, i in zip(multiInterval, intervals): self.assertEqual(m, i) number += 1 self.assertEqual(number, len(intervals)) # Test ArithmeticAdd a = Gf.MultiInterval( [ Gf.Interval( -10, 1, True, False), Gf.Interval( 3, 4, False, True ), Gf.Interval( 100, 200, False, True), Gf.Interval( 201, 300, False, True)]) a.ArithmeticAdd(Gf.Interval( -3, -1, False, True )) result = Gf.MultiInterval( [ Gf.Interval( -13, 0, False, False), Gf.Interval( 0, 3, False, True ), Gf.Interval( 97, 299, False, True)]) self.assertEqual(a, result)
def test_ClipManifest(self): """Verifies behavior with value clips when a clip manifest is specified.""" stage = Usd.Stage.Open('manifest/root.usda') prim = stage.GetPrimAtPath('/WithManifestClip') # This attribute doesn't exist in the manifest, so we should # not have looked in any clips for samples, and its value should # fall back to its default value. notInManifestAndInClip = prim.GetAttribute('notInManifestAndInClip') self.assertFalse(notInManifestAndInClip.ValueMightBeTimeVarying()) self.assertFalse(Sdf.Layer.Find('manifest/clip_1.usda')) self.assertFalse(Sdf.Layer.Find('manifest/clip_2.usda')) _Check(self.assertEqual, notInManifestAndInClip, time=0, expected=3.0) self.assertEqual(notInManifestAndInClip.GetTimeSamples(), []) self.assertEqual( notInManifestAndInClip.GetTimeSamplesInInterval( Gf.Interval.GetFullInterval()), []) ValidateAttributeTimeSamples(notInManifestAndInClip) # This attribute also doesn't exist in the manifest and also # does not have any samples in the clips. It should behave exactly # as above; we should not have to open any of the clips. notInManifestNotInClip = prim.GetAttribute('notInManifestNotInClip') self.assertFalse(notInManifestNotInClip.ValueMightBeTimeVarying()) self.assertFalse(Sdf.Layer.Find('manifest/clip_1.usda')) self.assertFalse(Sdf.Layer.Find('manifest/clip_2.usda')) _Check(self.assertEqual, notInManifestNotInClip, time=0, expected=4.0) self.assertEqual( notInManifestNotInClip.GetTimeSamplesInInterval( Gf.Interval.GetFullInterval()), []) ValidateAttributeTimeSamples(notInManifestNotInClip) # This attribute is in the manifest but is declared uniform, # so we should also not look in any clips for samples. uniformInManifestAndInClip = prim.GetAttribute( 'uniformInManifestAndInClip') self.assertFalse(uniformInManifestAndInClip.ValueMightBeTimeVarying()) self.assertFalse(Sdf.Layer.Find('manifest/clip_1.usda')) self.assertFalse(Sdf.Layer.Find('manifest/clip_2.usda')) _Check(self.assertEqual, uniformInManifestAndInClip, time=0, expected=5.0) self.assertEqual(uniformInManifestAndInClip.GetTimeSamples(), []) self.assertEqual( uniformInManifestAndInClip.GetTimeSamplesInInterval( Gf.Interval.GetFullInterval()), []) ValidateAttributeTimeSamples(uniformInManifestAndInClip) # This attribute is in the manifest and has samples in the # first clip, but not the other. We should get the clip's samples # in the first time range, and the default value in the second # range. inManifestAndInClip = prim.GetAttribute('inManifestAndInClip') self.assertTrue(inManifestAndInClip.ValueMightBeTimeVarying()) # We should only have needed to open the first clip to determine # if the attribute might be varying. self.assertTrue(Sdf.Layer.Find('manifest/clip_1.usda')) self.assertFalse(Sdf.Layer.Find('manifest/clip_2.usda')) _Check(self.assertEqual, inManifestAndInClip, time=0, expected=0.0) _Check(self.assertEqual, inManifestAndInClip, time=1, expected=-1.0) _Check(self.assertEqual, inManifestAndInClip, time=2, expected=1.0) self.assertEqual(inManifestAndInClip.GetTimeSamples(), [0.0, 1.0, 2.0]) self.assertEqual( inManifestAndInClip.GetTimeSamplesInInterval(Gf.Interval(0, 2.1)), [0.0, 1.0, 2.0]) ValidateAttributeTimeSamples(inManifestAndInClip) # Close and reopen the stage to ensure the clip layers are closed # before we do the test below. stage.Close() self.assertFalse(Sdf.Layer.Find('manifest/clip_1.usda')) self.assertFalse(Sdf.Layer.Find('manifest/clip_2.usda')) # Lastly, this attribute is in the manifest but has no # samples in the clip, so we should just fall back to the default # value. stage = Usd.Stage.Open('manifest/root.usda') prim = stage.GetPrimAtPath('/WithManifestClip') inManifestNotInClip = prim.GetAttribute('inManifestNotInClip') self.assertFalse(inManifestNotInClip.ValueMightBeTimeVarying()) # Since the attribute is in the manifest, we have to search all # the clips to see which of them have samples. In this case, none # of them do, so we fall back to the default value. self.assertTrue(Sdf.Layer.Find('manifest/clip_1.usda')) self.assertTrue(Sdf.Layer.Find('manifest/clip_2.usda')) _Check(self.assertEqual, inManifestNotInClip, time=0, expected=2.0) self.assertEqual(inManifestNotInClip.GetTimeSamples(), []) self.assertEqual( inManifestNotInClip.GetTimeSamplesInInterval( Gf.Interval.GetFullInterval()), []) ValidateAttributeTimeSamples(inManifestNotInClip)
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_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) self.assertEqual(default1, Usd.TimeCode(default1)) 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]) bothOpen = Gf.Interval(1.0, 2.0, False, False) self.assertEqual([], attr.GetTimeSamplesInInterval(bothOpen)) finiteMinClosed = Gf.Interval(1.0, 2.0, True, False) self.assertEqual([1.0], attr.GetTimeSamplesInInterval(finiteMinClosed)) finiteMaxClosed = Gf.Interval(1.0, 2.0, False, True) self.assertEqual([2.0], attr.GetTimeSamplesInInterval(finiteMaxClosed)) # Ensure that an empty interval returns nothing emptyInterval = Gf.Interval() self.assertEqual([], attr.GetTimeSamplesInInterval(emptyInterval)) emptyInterval2 = Gf.Interval(50, 1) self.assertEqual([], attr.GetTimeSamplesInInterval(emptyInterval2)) 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 runTest(self): testIntervals = [] inf = float("inf") # Empty interval i0 = Gf.Interval() testIntervals.append(i0) self.assertTrue(i0.isEmpty) # Non-empty: [1,1] i1 = Gf.Interval(1) testIntervals.append(i1) self.assertFalse(i1.isEmpty) self.assertEqual(i1.min, 1) self.assertEqual(i1.max, 1) self.assertTrue(i1.minClosed) self.assertTrue(i1.maxClosed) self.assertFalse(i1.minOpen) self.assertFalse(i1.maxOpen) self.assertEqual(i1.size, 0) self.assertFalse(i1.Contains(0.99)) self.assertTrue(i1.Contains(1)) self.assertFalse(i1.Contains(1.01)) # Non-empty: [2,4] fully closed i2 = Gf.Interval(2, 4) testIntervals.append(i2) self.assertFalse(i2.isEmpty) self.assertEqual(i2.min, 2) self.assertEqual(i2.max, 4) self.assertTrue(i2.minClosed) self.assertTrue(i2.maxClosed) self.assertEqual(i2.size, 2) self.assertFalse(i2.Contains(1.99)) self.assertTrue(i2.Contains(2.00)) self.assertTrue(i2.Contains(2.01)) self.assertTrue(i2.Contains(3.99)) self.assertTrue(i2.Contains(4.00)) self.assertFalse(i2.Contains(4.01)) # Non-empty: (1,3] half-open i3 = Gf.Interval(1, 3, False, True) testIntervals.append(i3) self.assertFalse(i3.isEmpty) self.assertEqual(i3.min, 1) self.assertEqual(i3.max, 3) self.assertTrue(i3.minOpen) self.assertTrue(i3.maxClosed) self.assertEqual(i3.size, 2) self.assertFalse(i3.Contains(0.99)) self.assertFalse(i3.Contains(1.00)) self.assertTrue(i3.Contains(1.01)) self.assertTrue(i3.Contains(2.99)) self.assertTrue(i3.Contains(3.00)) self.assertFalse(i3.Contains(3.01)) # Non-empty: [-1,2) half-open i4 = Gf.Interval(-1, 2, True, False) testIntervals.append(i4) self.assertFalse(i4.isEmpty) self.assertEqual(i4.min, -1) self.assertEqual(i4.max, 2) self.assertTrue(i4.minClosed) self.assertTrue(i4.maxOpen) self.assertEqual(i4.size, 3) self.assertFalse(i4.Contains(-1.01)) self.assertTrue(i4.Contains(-1.00)) self.assertTrue(i4.Contains(-0.99)) self.assertTrue(i4.Contains(1.99)) self.assertFalse(i4.Contains(2.00)) self.assertFalse(i4.Contains(2.01)) # Non-empty: (2,4) fully open i5 = Gf.Interval(2, 4, False, False) testIntervals.append(i5) self.assertFalse(i5.isEmpty) self.assertEqual(i5.min, 2) self.assertEqual(i5.max, 4) self.assertTrue(i5.minOpen) self.assertTrue(i5.maxOpen) self.assertEqual(i5.size, 2) self.assertFalse(i5.Contains(1.99)) self.assertFalse(i5.Contains(2.00)) self.assertTrue(i5.Contains(2.01)) self.assertTrue(i5.Contains(3.99)) self.assertFalse(i5.Contains(4.00)) self.assertFalse(i5.Contains(4.01)) # Empty degenerate intervals: self.assertTrue(Gf.Interval(1, 0).isEmpty) self.assertTrue(Gf.Interval(0, 0, False, True).isEmpty) self.assertTrue(Gf.Interval(0, 0, True, False).isEmpty) # Test (in)equality for i in range(len(testIntervals)): for j in range(len(testIntervals)): self.assertTrue((i==j) == (testIntervals[i] == testIntervals[j])) # Test repr() for i in testIntervals: self.assertEqual(eval(repr(i)), i) for i in testIntervals: self.assertEqual(i + Gf.Interval(), i, i) self.assertEqual(Gf.Interval() | i, i) # Test | self.assertEqual((i1 | i2), Gf.Interval(1, 4)) self.assertEqual((i1 | i3), Gf.Interval(1, 3)) self.assertEqual((i1 | i4), Gf.Interval(-1, 2, True, False)) self.assertEqual((i1 | i5), Gf.Interval(1, 4, True, False)) self.assertEqual((i3 | i5), Gf.Interval(1, 4, False, False)) # Test & self.assertTrue((i1 & i2).isEmpty) self.assertTrue((i1 & i3).isEmpty) self.assertEqual((i1 & i4), i1) self.assertTrue((i1 & i5).isEmpty) self.assertTrue((i4 & i5).isEmpty) # adjacent open boundaries have no intersection self.assertEqual((i3 & i5), Gf.Interval(2, 3, False, True)) # operators i1 = Gf.Interval(10, 20, False, True) i1 &= Gf.Interval(15, 25, False, False) self.assertEqual(i1.min, 15, ("&=")) self.assertEqual(i1.max, 20, ("&=")) self.assertTrue(i1.minOpen) self.assertTrue(i1.maxClosed) i1 = Gf.Interval(10, 20) & Gf.Interval(15, 25) self.assertEqual(i1.min, 15, ("&")) self.assertEqual(i1.max, 20, ("&")) self.assertTrue(i1.minClosed) self.assertTrue(i1.maxClosed) i1 = Gf.Interval(10, 20) i1 |= Gf.Interval(15, 25) self.assertEqual(i1.min, 10, ("|=")) self.assertEqual(i1.max, 25, ("|=")) i1 = Gf.Interval(10, 20) | Gf.Interval(15, 25) self.assertEqual(i1.min, 10, ("|")) self.assertEqual(i1.max, 25, ("|")) i1 = Gf.Interval(10, 20) i1 += Gf.Interval(30, 40) self.assertTrue(i1.min == 40 and i1.max == 60, ("+=")) i1 = Gf.Interval(10, 20) i1 -= Gf.Interval(30, 40) self.assertTrue(i1.min == -30 and i1.max == -10, ("-=")) i1 = Gf.Interval(10, 20) i1 *= Gf.Interval(30, 40) self.assertTrue(i1.min == 300 and i1.max == 800, ("*=")) i1 = -Gf.Interval(10, 20) self.assertTrue(i1.min == -20 and i1.max == -10, ("unary -")) i1 = Gf.Interval(10, 20) + Gf.Interval(20, 30) self.assertTrue(i1.min == 30 and i1.max == 50, ("+")) i1 = Gf.Interval(10, 20) - Gf.Interval(20, 30) self.assertTrue(i1.min == -20 and i1.max == 0, ("-")) i1 = Gf.Interval(10, 20) * Gf.Interval(20, 30) self.assertEqual(i1.min, 200) self.assertEqual(i1.max, 600) self.assertTrue(i1.minClosed) self.assertTrue(i1.maxClosed) i1 = Gf.Interval(10, 20, False, True) * Gf.Interval(20, 30, True, False) self.assertEqual(i1.min, 200) self.assertEqual(i1.max, 600) self.assertTrue(i1.minOpen) self.assertTrue(i1.maxOpen) i1 = Gf.Interval(-10, 20, False, True) * Gf.Interval(-20, 30, True, False) self.assertEqual(i1.min, -400) self.assertEqual(i1.max, 600) self.assertTrue(i1.minClosed) self.assertTrue(i1.maxOpen) i1 = Gf.Interval.GetFullInterval() i2 = Gf.Interval(0, 1) self.assertEqual(i1, Gf.Interval(-inf, inf, False, False)) self.assertEqual((i1 & i2), i2) #Test normalization of all infinite intervals as open intervals i1 = Gf.Interval.GetFullInterval() i2 = Gf.Interval(-inf, inf, False, False) i3 = Gf.Interval(-inf, inf, True, False) i4 = Gf.Interval(-inf, inf, False, True) i5 = Gf.Interval(-inf, inf, True, True) i6 = Gf.Interval(-inf, inf) self.assertEqual(i1, i2) self.assertEqual(i1, i3) self.assertEqual(i1, i4) self.assertEqual(i1, i5) self.assertEqual(i1, i6) # Test bounds i = Gf.Interval.GetFullInterval() self.assertFalse(i.minFinite) self.assertFalse(i.maxFinite) self.assertFalse(i.finite) i = Gf.Interval(-inf, -inf) self.assertFalse(i.minFinite) self.assertFalse(i.maxFinite) self.assertFalse(i.finite) i = Gf.Interval(inf, inf) self.assertFalse(i.minFinite) self.assertFalse(i.maxFinite) self.assertFalse(i.finite) i = Gf.Interval(inf, 0.0) self.assertFalse(i.minFinite) self.assertTrue(i.maxFinite) self.assertFalse(i.finite) i = Gf.Interval(0.0, inf) self.assertTrue(i.minFinite) self.assertFalse(i.maxFinite) self.assertFalse(i.finite) i = Gf.Interval(0.0, 1.0) self.assertTrue(i.minFinite) self.assertTrue(i.maxFinite) self.assertTrue(i.finite) # Test representations self.assertTrue(i1.min == eval(repr(i1)).min and \ i1.max == eval(repr(i1)).max, ("repr")) self.assertTrue(len(str(Gf.Interval())), ("str"))