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