def testCanWriteAnimatedPositions( self ):
fileName = self.getOutputPath("usd_animated_positions.usda")
sceneWrite = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Write )
root = sceneWrite.createChild( "root" )
child = root.createChild( "child" )
for t in range( 64 ):
planeDimensions = imath.Box2f( imath.V2f( 0, 0 ), imath.V2f( 1 + t, 1 ) )
planeDivisions = imath.V2i( 1, 1 )
plane = IECoreScene.MeshPrimitive.createPlane( planeDimensions, planeDivisions )
child.writeObject( plane, t )
del child
del root
del sceneWrite
sceneRead = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
root = sceneRead.child( "root" )
child = root.child( "child" )
for t in range( 64 ):
readObject = child.readObject ( t )
self.assertEqual(readObject["P"].data[1][0], 1 + t)
def testReferencedData(self):
p1 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(0)))
p1["Pref"] = p1["P"]
p2 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(0), imath.V2f(1)))
merged = IECoreScene.MeshMergeOp()(input=p1, mesh=p2)
self.failUnless("Pref" in merged)
self.verifyMerge(p1, p2, merged)
del p1["Pref"]
p2["Pref"] = p2["P"]
merged = IECoreScene.MeshMergeOp()(input=p1, mesh=p2)
self.failUnless("Pref" in merged)
self.verifyMerge(p1, p2, merged)
def testTagsAsSets( self ) : s = IECoreScene.SceneCache( "/tmp/test.scc", IECore.IndexedIO.OpenMode.Write ) sphereGroup = s.createChild( "sphereGroup" ) sphereGroup.writeTags( [ "chrome" ] ) sphere = sphereGroup.createChild( "sphere" ) sphere.writeObject( IECoreScene.SpherePrimitive(), 0 ) planeGroup = s.createChild( "planeGroup" ) plane = planeGroup.createChild( "plane" ) plane.writeTags( [ "wood", "something" ] ) plane.writeObject( IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) ), 0 ) del s, sphereGroup, sphere, planeGroup, plane s = GafferScene.SceneReader() s["fileName"].setValue( "/tmp/test.scc" ) s["refreshCount"].setValue( self.uniqueInt( "/tmp/test.scc" ) ) # account for our changing of file contents between tests self.assertEqual( set( [ str( ss ) for ss in s["out"]["setNames"].getValue() ] ), set( [ "ObjectType:SpherePrimitive", "wood", "chrome", "ObjectType:MeshPrimitive", "something" ] ) ) self.assertEqual( s["out"].set( "chrome" ).value.paths(), [ "/sphereGroup" ] ) self.assertEqual( s["out"].set( "wood" ).value.paths(), [ "/planeGroup/plane" ] ) self.assertEqual( s["out"].set( "something" ).value.paths(), [ "/planeGroup/plane" ] ) self.assertEqual( s["out"].set( "ObjectType:SpherePrimitive" ).value.paths(), [ "/sphereGroup/sphere" ] ) self.assertEqual( s["out"].set( "ObjectType:MeshPrimitive" ).value.paths(), [ "/planeGroup/plane" ] )
def testCancel( self ) : canceller = IECore.Canceller() cancelled = [False] # Basic large mesh strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 3000000, 1 ) ), imath.V2i( 3000000, 1 ) ) def backgroundRun(): try: IECoreScene.MeshAlgo.triangulate( strip, canceller ) except IECore.Cancelled: cancelled[0] = True thread = threading.Thread(target=backgroundRun, args=()) startTime = time.time() thread.start() time.sleep( 0.1 ) canceller.cancel() thread.join() # This test should actually produce a time extremely close to the sleep duration ( within # 0.01 seconds whether the sleep duration is 0.01 seconds or 1 seconds ), but checking # that it terminates with 0.1 seconds is a minimal performance bar self.assertLess( time.time() - startTime, 0.2 ) self.assertTrue( cancelled[0] )
def testReferencedData(self):
p1 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(0)))
p1["Pref"] = p1["P"]
p2 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(0), imath.V2f(1)))
merged = IECoreScene.MeshAlgo.merge([p1, p2])
self.failUnless("Pref" in merged)
self.verifyMerge(merged, [p1, p2])
del p1["Pref"]
p2["Pref"] = p2["P"]
merged = IECoreScene.MeshAlgo.merge([p1, p2])
self.failUnless("Pref" in merged)
self.verifyMerge(merged, [p1, p2])
def testVisualisation( self ) :
r = IECoreGL.Renderer()
r.setOption( "gl:mode", IECore.StringData( "immediate" ) )
r.camera( "main", {
"projection" : IECore.StringData( "orthographic" ),
"resolution" : IECore.V2iData( imath.V2i( 256 ) ),
"clippingPlanes" : IECore.V2fData( imath.V2f( 1, 1000 ) ),
"screenWindow" : IECore.Box2fData( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) )
}
)
r.display( self.__outputFileName, "tif", "rgba", {} )
r.setOption( "gl:drawCoordinateSystems", IECore.BoolData( True ) )
with IECoreScene.WorldBlock( r ) :
r.concatTransform( imath.M44f().translate( imath.V3f( 0, 0, -5 ) ) )
r.coordinateSystem( "myCoordSys" )
i = IECore.Reader.create( self.__outputFileName ).read()
a = i["A"]
self.assertTrue( a[127*256 + 127] > 0 )
self.assertTrue( a[127*256 + 255] > 0 )
self.assertTrue( a[127] > 0 )
self.assertEqual( a[200*127 + 127], 0 )
self.assertEqual( a[120*127 + 127], 0 )
def testFaceVaryingUVsWithoutIndices( self ) : plane = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ), divisions = imath.V2i( 2, 1 ) ) uv = plane["uv"] uv.data = uv.expandedData() uv.indices = None plane["uv"] = uv objectToScene = GafferScene.ObjectToScene() objectToScene["object"].setValue( plane ) filter = GafferScene.PathFilter() filter["paths"].setValue( IECore.StringVectorData( [ "/object" ] ) ) wireframe = GafferScene.Wireframe() wireframe["in"].setInput( objectToScene["out"] ) wireframe["filter"].setInput( filter["out"] ) wireframe["position"].setValue( "uv" ) self.assertSceneValid( wireframe["out"] ) # Because we removed the indices, there is no connectivity information, # and therefore no shared edges, so we expect to see 8 curves. curves = wireframe["out"].object( "/object" ) self.assertEqual( len( curves.verticesPerCurve() ), 8 )
def testIndexedUniformPrimitiveVariables(self):
# We expect uniform indexed variables to be expanded out fully
# when converting to Arnold, because Arnold only supports indexing
# for FaceVarying variables.
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)),
imath.V2i(4, 1),
)
self.assertEqual(
m.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.Uniform), 4)
m["myPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Uniform,
IECore.FloatVectorData([5, 10]), IECore.IntVectorData([0, 1, 0,
1]))
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
self.assertEqual(
arnold.AiNodeLookUpUserParameter(n, "myPrimVaridxs"), None)
a = arnold.AiNodeGetArray(n, "myPrimVar")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
for i in range(0, 4):
self.assertEqual(
arnold.AiArrayGetFlt(a, i),
m["myPrimVar"].data[m["myPrimVar"].indices[i]])
def testPointTypePrimitiveVariables(self):
# make sure that we can add prim vars of both vector and point type, and differentiate between the two.
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
points = IECore.V3fVectorData([])
IECore.setGeometricInterpretation(
points, IECore.GeometricData.Interpretation.Point)
m["points"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex, points)
vectors = IECore.V3fVectorData([])
IECore.setGeometricInterpretation(
vectors, IECore.GeometricData.Interpretation.Vector)
m["vectors"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex, vectors)
with IECoreArnold.UniverseBlock(writable=True):
node = IECoreArnold.NodeAlgo.convert(m, "testMesh")
p = arnold.AiNodeGetArray(node, "points")
self.assertEqual(arnold.AiArrayGetType(p.contents),
arnold.AI_TYPE_VECTOR)
v = arnold.AiNodeGetArray(node, "vectors")
self.assertEqual(arnold.AiArrayGetType(v.contents),
arnold.AI_TYPE_VECTOR)
def testAdditionalUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myMap"] = m["uv"]
uvData = m["myMap"].data
indicesData = m["myMap"].indices
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
uvs = arnold.AiNodeGetArray(n, "myMap")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "myMapidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
p = arnold.AiArrayGetVec2(uvs, i)
self.assertEqual(arnold.AiArrayGetVec2(uvs, i),
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(arnold.AiArrayGetInt(uvIndices, i),
indicesData[i])
def testIndexedFaceVaryingPrimitiveVariables(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)),
imath.V2i(2, 1),
)
self.assertEqual(
m.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying), 8)
m["myPrimVar"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
IECore.FloatVectorData([5, 10]),
IECore.IntVectorData([0, 0, 0, 0, 1, 1, 1, 1]))
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
a = arnold.AiNodeGetArray(n, "myPrimVar")
ia = arnold.AiNodeGetArray(n, "myPrimVaridxs")
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 2)
self.assertEqual(arnold.AiArrayGetNumElements(ia.contents), 8)
for i in range(0, len(m["myPrimVar"].data)):
self.assertEqual(arnold.AiArrayGetFlt(a, i),
m["myPrimVar"].data[i])
for i in range(0, len(m["myPrimVar"].indices)):
self.assertEqual(arnold.AiArrayGetUInt(ia, i),
m["myPrimVar"].indices[i])
def testSegmentSubset(self):
mesh = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(0), imath.V2f(2)), imath.V2i(2))
mesh["s"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Uniform,
IECore.StringVectorData(["a", "a", "a", "b"]))
segmentValues = IECore.StringVectorData(["b"])
segments = IECoreScene.MeshAlgo.segment(mesh, mesh["s"], segmentValues)
p00 = imath.V3f(0, 0, 0)
p10 = imath.V3f(1, 0, 0)
p20 = imath.V3f(2, 0, 0)
p01 = imath.V3f(0, 1, 0)
p11 = imath.V3f(1, 1, 0)
p21 = imath.V3f(2, 1, 0)
p02 = imath.V3f(0, 2, 0)
p12 = imath.V3f(1, 2, 0)
p22 = imath.V3f(2, 2, 0)
self.assertEqual(len(segments), 1)
self.assertEqual(
segments[0]["P"].data,
IECore.V3fVectorData([p11, p21, p12, p22],
IECore.GeometricData.Interpretation.Point))
self.assertEqual(segments[0]["s"].data, IECore.StringVectorData(["b"]))
def testNameClashesWithThreading(self):
sphere = IECoreScene.SpherePrimitive()
input1 = GafferSceneTest.CompoundObjectSource()
input1["in"].setValue(
IECore.CompoundObject({
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"myLovelyObject1": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
},
}), )
plane = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
input2 = GafferSceneTest.CompoundObjectSource()
input2["in"].setValue(
IECore.CompoundObject({
"bound": IECore.Box3fData(plane.bound()),
"children": {
"myLovelyObject1": {
"bound": IECore.Box3fData(plane.bound()),
"object": plane,
},
},
}), )
group = GafferScene.Group()
group["name"].setValue("topLevel")
group["in"][0].setInput(input1["out"])
group["in"][1].setInput(input2["out"])
GafferSceneTest.traverseScene(group["out"])
def testTransform( self ) : r = GafferScene.Private.IECoreScenePreview.Renderer.create( "3Delight", GafferScene.Private.IECoreScenePreview.Renderer.RenderType.SceneDescription, self.temporaryDirectory() + "/test.nsi", ) m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) ) a = r.attributes( IECore.CompoundObject() ) r.object( "untransformed", m, a ) r.object( "identity", m, a ).transform( imath.M44f() ) r.object( "transformed", m, a ).transform( imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) r.object( "animated", m, a ).transform( [ imath.M44f().translate( imath.V3f( x, 0, 0 ) ) for x in range( 0, 2 ) ], [ 0, 1 ] ) r.render() del r nsi = self.__parse( self.temporaryDirectory() + "/test.nsi" ) self.__assertNotInNSI( 'DeleteAttribute', nsi ) self.__assertNotInNSI( 'SetAttribute "untransformed" "transformationmatrix"', nsi ) self.__assertNotInNSI( 'SetAttribute "identity" "transformationmatrix"', nsi ) self.__assertInNSI( 'SetAttribute "transformed" "transformationmatrix" "doublematrix" 1 [ 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 ]', nsi ) self.__assertInNSI( 'SetAttributeAtTime "animated" 0 "transformationmatrix" "doublematrix" 1 [ 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 ]', nsi ) self.__assertInNSI( 'SetAttributeAtTime "animated" 1 "transformationmatrix" "doublematrix" 1 [ 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 ]', nsi )
def testPrimVarInterpolationChangeSkipped(self):
m1 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m2 = m1.copy()
m1["v"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1, 2, 3, 4]),
IECore.IntVectorData([0, 1, 2, 3]))
m2["v"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([4, 3, 2, 1]))
with IECore.CapturingMessageHandler() as mh:
m3 = IECore.linearObjectInterpolation(m1, m2, 0.5)
self.assertEqual(len(mh.messages), 1)
self.assertEqual(mh.messages[0].level, IECore.Msg.Level.Error)
self.assertEqual(mh.messages[0].context, "interpolatePrimitive")
self.assertEqual(
mh.messages[0].message,
"primitive variable 'v' indexing changes between primitives")
self.assertTrue("v" in m3)
self.assertEqual(m3["v"], m1["v"])
def testColor4fVectorDataPrimimitiveVariable(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myColor"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.Color4fVectorData([
imath.Color4f(1, 0, 0, 1),
imath.Color4f(0, 2, 0, 0),
imath.Color4f(0, 0, 3, 0.25),
imath.Color4f(4, 0, 0, 1),
]))
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
a = arnold.AiNodeGetArray(n, "myColor")
self.assertEqual(arnold.AiArrayGetType(a.contents),
arnold.AI_TYPE_RGBA)
self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4)
self.assertEqual(arnold.AiArrayGetRGBA(a, 0),
arnold.AtRGBA(1, 0, 0, 1))
self.assertEqual(arnold.AiArrayGetRGBA(a, 1),
arnold.AtRGBA(0, 2, 0, 0))
self.assertEqual(arnold.AiArrayGetRGBA(a, 2),
arnold.AtRGBA(0, 0, 3, 0.25))
self.assertEqual(arnold.AiArrayGetRGBA(a, 3),
arnold.AtRGBA(4, 0, 0, 1))
def testPrimitiveInterpolationMaintainsUninterpolableValuesFromFirstPrimitive(
self):
m1 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m1["c"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Constant,
IECore.StringData("hi"))
m2 = m1.copy()
m3 = IECore.linearObjectInterpolation(m1, m2, 0.5)
self.assertEqual(
m3["c"],
IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Constant,
IECore.StringData("hi")))
m2["c"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Constant,
IECore.StringData("bye"))
m3 = IECore.linearObjectInterpolation(m1, m2, 0.5)
self.assertEqual(
m3["c"],
IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Constant,
IECore.StringData("hi")))
def testUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["uv"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
m["uv"].expandedData())
uvData = m["uv"].data
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
p = arnold.AiArrayGetVec2(uvs, i)
self.assertEqual(arnold.AiArrayGetVec2(uvs, i),
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(arnold.AiArrayGetInt(uvIndices, i), i)
def testValueTypes(self):
for v in [
IECore.FloatVectorData([1, 2, 3]),
IECore.IntVectorData([1, 2, 3]),
IECore.StringVectorData(["1", "2", "3"]),
IECore.V3fVectorData([imath.V3f(x) for x in range(1, 5)]),
IECore.Color3fVectorData(
[imath.Color3f(x) for x in range(1, 5)]),
IECore.M44fVectorData([imath.M44f() * x for x in range(1, 5)]),
IECore.V2iVectorData([imath.V2i(x) for x in range(1, 5)]),
IECore.V3fData(imath.V3f(1, 2, 3)),
IECore.V2fData(imath.V2f(1, 2)),
IECore.M44fData(imath.M44f(*range(16))),
IECore.Box2fData(imath.Box2f(imath.V2f(0, 1), imath.V2f(1,
2))),
IECore.Box2iData(
imath.Box2i(imath.V2i(-1, 10), imath.V2i(11, 20))),
IECore.Box3fData(
imath.Box3f(imath.V3f(0, 1, 2), imath.V3f(3, 4, 5))),
IECore.Box3iData(
imath.Box3i(imath.V3i(0, 1, 2), imath.V3i(3, 4, 5))),
IECore.InternedStringVectorData(["a", "b"])
]:
if 'value' in dir(v):
expected = v.value
else:
expected = v
self.assertEqual(
expected,
Gaffer.NameValuePlug("test", v)["value"].getValue())
def testIndexedUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
uvData = m["uv"].data
uvIds = m["uv"].indices
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(m, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
aiUv = arnold.AiArrayGetVec2(uvs, i)
aiUVId = arnold.AiArrayGetInt(uvIndices, i)
aiIndexedUV = arnold.AiArrayGetVec2(uvs, aiUVId)
self.assertEqual(aiUVId, uvIds[i])
self.assertEqual(aiUv,
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(
aiIndexedUV,
arnold.AtVector2(uvData[uvIds[i]][0], uvData[uvIds[i]][1]))
def testPlane(self):
p = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
if "N" in p:
del p["N"]
self.assert_(not "N" in p)
pp = IECoreScene.MeshNormalsOp()(input=p)
self.assert_("N" in pp)
self.assertEqual(pp["N"].interpolation,
IECoreScene.PrimitiveVariable.Interpolation.Vertex)
normals = pp["N"].data
self.assert_(normals.isInstanceOf(IECore.V3fVectorData.staticTypeId()))
self.assertEqual(
normals.size(),
pp.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.Vertex))
self.assertEqual(normals.getInterpretation(),
IECore.GeometricData.Interpretation.Normal)
for n in normals:
self.assertEqual(n, imath.V3f(0, 0, 1))
def makeRandomBound(self):
b1 = imath.V2f(random.random(), random.random())
b2 = imath.V2f(random.random(), random.random())
bound = imath.Box2f(b1)
bound.extendBy(b2)
return bound
def rectanglePoints( self, bound = imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ), divisions = imath.V2i( 10 ) ) :
r = imath.Rand48()
pData = IECore.V3fVectorData()
uData = IECore.FloatVectorData()
vData = IECore.FloatVectorData()
floatUserData = IECore.FloatVectorData()
colorUserData = IECore.Color3fVectorData()
doubleUserData = IECore.DoubleVectorData()
for y in range( 0, divisions.y ) :
for x in range( 0, divisions.x ) :
u = float( x ) / float( divisions.x - 1 )
v = float( y ) / float( divisions.y - 1 )
pData.append( imath.V3f(
bound.min().x + u * bound.size().x,
bound.min().y + v * bound.size().y,
0
) )
uData.append( u )
vData.append( v )
floatUserData.append( r.nextf( 0, 1 ) )
colorUserData.append( imath.Color3f( r.nextf(), r.nextf(), r.nextf() ) )
doubleUserData.append( y * divisions.x + x )
return IECore.CompoundData( {
"P" : pData,
"u" : uData,
"v" : vData,
"floatUserData" : floatUserData,
"colorUserData" : colorUserData,
"doubleUserData" : doubleUserData
} )
def testPointsPrimitiveSelect(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.setAttribute("name", IECore.StringData("pointsNeedSelectingToo"))
r.points(
1, {
"P":
IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(0)]))
})
s = r.scene()
s.setCamera(IECoreGL.Camera(imath.M44f(), False))
for mode in (IECoreGL.Selector.Mode.GLSelect,
IECoreGL.Selector.Mode.OcclusionQuery,
IECoreGL.Selector.Mode.IDRender):
ss = s.select(mode, imath.Box2f(imath.V2f(0), imath.V2f(1)))
names = [
IECoreGL.NameStateComponent.nameFromGLName(x.name) for x in ss
]
self.assertEqual(len(names), 1)
self.assertEqual(names[0], "pointsNeedSelectingToo")
def testBound(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-0.5), imath.V2f(0.5)))
m2 = IECoreGL.ToGLMeshConverter(m).convert()
self.assertEqual(m.bound(), m2.bound())
def testSelectableFlag(self):
r = IECoreGL.Renderer()
r.setOption("gl:mode", IECore.StringData("deferred"))
r.setOption("gl:searchPath:shader",
IECore.StringData(os.path.dirname(__file__) + "/shaders"))
with IECoreScene.WorldBlock(r):
r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5)))
r.setAttribute("name", IECore.StringData("selectableObj"))
r.shader(
"surface", "color",
{"colorValue": IECore.Color3fData(imath.Color3f(1, 0, 0))})
r.sphere(1, -1, 1, 360, {})
r.concatTransform(imath.M44f().translate(imath.V3f(-1, 0, 0)))
r.setAttribute("name", IECore.StringData("unselectableObj"))
r.setAttribute("gl:primitive:selectable", IECore.BoolData(False))
r.sphere(1, -1, 1, 360, {})
s = r.scene()
s.setCamera(IECoreGL.Camera(imath.M44f(), False))
for mode in (IECoreGL.Selector.Mode.GLSelect,
IECoreGL.Selector.Mode.OcclusionQuery,
IECoreGL.Selector.Mode.IDRender):
ss = s.select(mode, imath.Box2f(imath.V2f(0), imath.V2f(1)))
names = [
IECoreGL.NameStateComponent.nameFromGLName(x.name) for x in ss
]
self.assertEqual(names, ["selectableObj"])
def testTagFilteringPartialScene( self ) :
s = IECoreScene.SceneCache( "/tmp/test.scc", IECore.IndexedIO.OpenMode.Write )
sphereGroup = s.createChild( "sphereGroup" )
sphereGroup.writeTags( [ "chrome" ] )
sphere = sphereGroup.createChild( "sphere" )
sphere.writeObject( IECoreScene.SpherePrimitive(), 0 )
planeGroup = s.createChild( "planeGroup" )
plane = planeGroup.createChild( "plane" )
plane.writeTags( [ "wood", "something" ] )
plane.writeObject( IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) ), 0 )
del s, sphereGroup, sphere, planeGroup, plane
refreshCount = self.uniqueInt( "/tmp/test.scc" )
# this one will load everything
s1 = GafferScene.SceneReader()
s1["fileName"].setValue( "/tmp/test.scc" )
s1["refreshCount"].setValue( refreshCount )
# this one should load just the sphere
s2 = GafferScene.SceneReader()
s2["fileName"].setValue( "/tmp/test.scc" )
s2["refreshCount"].setValue( refreshCount )
s2["tags"].setValue( "chrome" )
# this one should load just the plane
s3 = GafferScene.SceneReader()
s3["fileName"].setValue( "/tmp/test.scc" )
s3["refreshCount"].setValue( refreshCount )
s3["tags"].setValue( "wood" )
# check childnames
self.assertEqual( set( [ str( x ) for x in s1["out"].childNames( "/" ) ] ), set( [ "sphereGroup", "planeGroup" ] ) )
self.assertEqual( set( [ str( x ) for x in s2["out"].childNames( "/" ) ] ), set( [ "sphereGroup" ] ) )
self.assertEqual( set( [ str( x ) for x in s3["out"].childNames( "/" ) ] ), set( [ "planeGroup" ] ) )
self.assertEqual( set( [ str( x ) for x in s1["out"].childNames( "/sphereGroup" ) ] ), set( [ "sphere" ] ) )
self.assertEqual( set( [ str( x ) for x in s2["out"].childNames( "/sphereGroup" ) ] ), set( [ "sphere" ] ) )
self.assertEqual( set( [ str( x ) for x in s1["out"].childNames( "/planeGroup" ) ] ), set( [ "plane" ] ) )
self.assertEqual( set( [ str( x ) for x in s3["out"].childNames( "/planeGroup" ) ] ), set( [ "plane" ] ) )
# check equality of the locations which are preserved
self.assertPathsEqual( s1["out"], "/", s2["out"], "/", checks = self.allPathChecks - { "childNames" } )
self.assertPathsEqual( s1["out"], "/", s3["out"], "/", checks = self.allPathChecks - { "childNames" } )
self.assertPathsEqual( s1["out"], "/sphereGroup/sphere", s2["out"], "/sphereGroup/sphere", checks = self.allPathChecks - { "childNames" } )
self.assertPathsEqual( s1["out"], "/sphereGroup/sphere", s2["out"], "/sphereGroup/sphere", checks = self.allPathChecks - { "childNames" } )
self.assertPathsEqual( s1["out"], "/planeGroup/plane", s3["out"], "/planeGroup/plane", checks = self.allPathChecks - { "childNames" } )
self.assertPathsEqual( s1["out"], "/planeGroup/plane", s3["out"], "/planeGroup/plane", checks = self.allPathChecks - { "childNames" } )
def testPrimVarsWithDifferingDataArraysAreSkipped(self):
m1 = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m2 = m1.copy()
m1["v"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1, 2, 1, 2]),
IECore.IntVectorData([0, 1, 2, 3]))
m2["v"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1, 2]), IECore.IntVectorData([0, 1, 0, 1]))
with IECore.CapturingMessageHandler() as mh:
m3 = IECore.linearObjectInterpolation(m1, m2, 0.5)
self.assertEqual(len(mh.messages), 1)
self.assertEqual(mh.messages[0].level, IECore.Msg.Level.Error)
self.assertEqual(mh.messages[0].context, "interpolatePrimitive")
self.assertEqual(
mh.messages[0].message,
"primitive variable 'v' data array size changes between primitives. ( primitive0 size: 4, primitive1 size: 2, alpha: 0.500000 )"
)
self.assertTrue("v" in m3)
self.assertEqual(m3["v"], m1["v"])
def testCancelLoading( self ) : strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 100000, 1 ) ), imath.V2i( 1000000, 1 ) ) testData = IECore.FloatVectorData( [0] * ( len( strip["P"].data ) ) ) for i in range( 10 ): q = IECore.FloatVectorData( testData ) q[0] = i strip["var%i" % i] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, q ) saveIO = IECore.MemoryIndexedIO( IECore.CharVectorData(), IECore.IndexedIO.OpenMode.Write ) strip.save( saveIO, "test" ) loadIO = IECore.MemoryIndexedIO( saveIO.buffer(), IECore.IndexedIO.OpenMode.Read ) canceller = IECore.Canceller() cancelled = [False] def backgroundRun(): try: IECore.Object.load( loadIO, "test", canceller ) except IECore.Cancelled: cancelled[0] = True thread = threading.Thread(target=backgroundRun, args=()) startTime = time.time() thread.start() time.sleep( 0.05 ) canceller.cancel() thread.join() self.assertLess( time.time() - startTime, 0.1 ) self.assertTrue( cancelled[0] )
def testCanWriteSimpleMesh( self ) :
fileName = self.getOutputPath("usd_simple_mesh.usda")
sceneWrite = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Write )
flatEarth = sceneWrite.createChild( "flatearth" )
planeDimensions = imath.Box2f( imath.V2f( 0, 0 ), imath.V2f( 1, 1 ) )
planeDivisions = imath.V2i( 16, 16 )
flatEarthObject = IECoreScene.MeshPrimitive.createPlane( planeDimensions, planeDivisions )
flatEarth.writeObject( flatEarthObject, 0.0 )
del flatEarth
del sceneWrite
sceneRead = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read )
self.assertEqual( sceneRead.childNames(), ["flatearth"] )
otherWorld = sceneRead.child( "flatearth" )
self.assertTrue( otherWorld.hasObject() )
object = otherWorld.readObject( 0.0 )
self.assertIsInstance( object, IECoreScene.MeshPrimitive )
otherMesh = object
self.assertTrue("P" in otherMesh)
