def testDoubleData(self): with IECoreArnold.UniverseBlock(writable=True): n = arnold.AiNode("standard_surface") IECoreArnold.ParameterAlgo.setParameter(n, "base", IECore.DoubleData(0.25)) self.assertEqual(arnold.AiNodeGetFlt(n, "base"), 0.25) IECoreArnold.ParameterAlgo.setParameter(n, "customFloat", IECore.DoubleData(0.25)) self.assertEqual(arnold.AiNodeGetFlt(n, "customFloat"), 0.25) IECoreArnold.ParameterAlgo.setParameter( n, "customMatrix", IECore.M44dData( imath.M44d(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))) m = arnold.AiNodeGetMatrix(n, "customMatrix") self.assertEqual( [list(i) for i in m.data], [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16] ], )
def testMotion(self): c1 = IECoreScene.CurvesPrimitive(IECore.IntVectorData([4])) c2 = IECoreScene.CurvesPrimitive(IECore.IntVectorData([4])) c1["P"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([imath.V3f(1)] * 4), ) c2["P"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([imath.V3f(2)] * 4), ) with IECoreArnold.UniverseBlock(writable=True) as universe: n = IECoreArnold.NodeAlgo.convert([c1, c2], -0.25, 0.25, universe, "testCurve") a = arnold.AiNodeGetArray(n, "points") self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4) self.assertEqual(arnold.AiArrayGetNumKeys(a.contents), 2) for i in range(0, 4): self.assertEqual(arnold.AiArrayGetVec(a, i), arnold.AtVector(1)) for i in range(4, 8): self.assertEqual(arnold.AiArrayGetVec(a, i), arnold.AtVector(2)) self.assertEqual(arnold.AiNodeGetFlt(n, "motion_start"), -0.25) self.assertEqual(arnold.AiNodeGetFlt(n, "motion_end"), 0.25)
def testSampleDeduplication(self): camera = IECoreScene.Camera() camera.setProjection("perspective") with IECoreArnold.UniverseBlock(writable=True): animatedNode = IECoreArnold.NodeAlgo.convert([camera, camera], 1.0, 2.0, "samples") node = IECoreArnold.NodeAlgo.convert(camera, "sample") for parameter in [ "screen_window_min", "screen_window_max", "fov", "aperture_size", "focus_distance", ]: if parameter.startswith("screen_"): self.assertEqual( arnold.AiNodeGetVec2(animatedNode, parameter).x, arnold.AiNodeGetVec2(node, parameter).x) self.assertEqual( arnold.AiNodeGetVec2(animatedNode, parameter).y, arnold.AiNodeGetVec2(node, parameter).y) else: self.assertEqual( arnold.AiNodeGetFlt(animatedNode, parameter), arnold.AiNodeGetFlt(node, parameter)) array = arnold.AiNodeGetArray(animatedNode, parameter) self.assertEqual(arnold.AiArrayGetNumElements(array), 1) self.assertEqual(arnold.AiArrayGetNumKeys(array), 1)
def testMotion( self ) : p1 = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( 10 ) ] * 10 ) ) p1["width"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData( [ 1 ] * 10 ), ) p2 = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( 20 ) ] * 10 ) ) p2["width"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData( [ 2 ] * 10 ), ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( [ p1, p2 ], -0.25, 0.25, "testPoints" ) a = arnold.AiNodeGetArray( n, "points" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 10 ) self.assertEqual( arnold.AiArrayGetNumKeys( a.contents ), 2 ) r = arnold.AiNodeGetArray( n, "radius" ) self.assertEqual( arnold.AiArrayGetNumElements( r.contents ), 10 ) self.assertEqual( arnold.AiArrayGetNumKeys( r.contents ), 2 ) for i in range( 0, 10 ) : self.assertEqual( arnold.AiArrayGetVec( a, i ), arnold.AtVector( 10 ) ) self.assertEqual( arnold.AiArrayGetFlt( r, i ), 0.5 ) for i in range( 11, 20 ) : self.assertEqual( arnold.AiArrayGetVec( a, i ), arnold.AtVector( 20 ) ) self.assertEqual( arnold.AiArrayGetFlt( r, i ), 1 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_start" ), -0.25 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_end" ), 0.25 )
def testDoubleData(self): with IECoreArnold.UniverseBlock(writable=True): n = arnold.AiNode("standard") IECoreArnold.ParameterAlgo.setParameter(n, "Kd", IECore.DoubleData(0.25)) self.assertEqual(arnold.AiNodeGetFlt(n, "Kd"), 0.25) IECoreArnold.ParameterAlgo.setParameter(n, "customFloat", IECore.DoubleData(0.25)) self.assertEqual(arnold.AiNodeGetFlt(n, "customFloat"), 0.25) IECoreArnold.ParameterAlgo.setParameter( n, "customMatrix", IECore.M44dData( IECore.M44d(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))) m = arnold.AtMatrix() arnold.AiNodeGetMatrix(n, "customMatrix", m) self.assertEqual( [getattr(m, f[0]) for f in m._fields_], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], )
def testConvertWithMotion( self ) : s = [ IECore.SpherePrimitive( 0.25 ), IECore.SpherePrimitive( 0.5 ) ] with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( s, 0, 1, "testSphere" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) a = arnold.AiNodeGetArray( n, "radius" ) self.assertEqual( arnold.AiArrayGetFlt( a, 0 ), 0.25 ) self.assertEqual( arnold.AiArrayGetFlt( a, 1 ), 0.5 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_start" ), 0 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_end" ), 1 )
def testConvertPerspective(self): with IECoreArnold.UniverseBlock(writable=True): n = IECoreArnold.NodeAlgo.convert( IECoreScene.Camera( parameters={ "projection": "perspective", "projection:fov": 45.0, "resolution": imath.V2i(512), "screenWindow": imath.Box2f(imath.V2f(-1, -0.5), imath.V2f(1, 0.5)) }), "testCamera") self.assertTrue( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n)), "persp_camera") self.assertEqual(arnold.AiNodeGetFlt(n, "fov"), 45.0) self.assertEqual(arnold.AiNodeGetVec2(n, "screen_window_min"), arnold.AtVector2(-1, -0.5)) self.assertEqual(arnold.AiNodeGetVec2(n, "screen_window_max"), arnold.AtVector2(1, 0.5))
def testProcedural(self): r = IECoreArnold.Renderer("/tmp/test.ass") with IECore.WorldBlock(r): r.procedural( r.ExternalProcedural( "someVolumeThing.so", IECore.Box3f(IECore.V3f(-1, -2, -3), IECore.V3f(4, 5, 6)), { "ai:nodeType": "volume", "testFloat": 0.5 })) volume = self.__allNodes(type=arnold.AI_NODE_SHAPE)[-1] self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(volume)), "volume") self.assertEqual(arnold.AiNodeGetPnt(volume, "min"), arnold.AtPoint(-1, -2, -3)) self.assertEqual(arnold.AiNodeGetPnt(volume, "max"), arnold.AtPoint(4, 5, 6)) self.assertEqual(arnold.AiNodeGetStr(volume, "dso"), "someVolumeThing.so") self.assertEqual(arnold.AiNodeGetFlt(volume, "testFloat"), 0.5)
def testConvertPerspective( self ) : with IECoreArnold.UniverseBlock( writable = True ) : c = IECoreScene.Camera( parameters = { "projection" : "perspective", "focalLength" : 1 / ( 2.0 * math.tan( 0.5 * math.radians( 45 ) ) ), "resolution" : imath.V2i( 512 ), "aperture" : imath.V2f( 2, 1 ) } ) n = IECoreArnold.NodeAlgo.convert( c, "testCamera" ) screenWindow = c.frustum() self.assertTrue( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "persp_camera" ) screenWindowMult = math.tan( 0.5 * math.radians( arnold.AiNodeGetFlt( n, "fov" ) ) ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).x, screenWindow.min()[0], 6 ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).y, screenWindow.min()[1], 6 ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).x, screenWindow.max()[0], 6 ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).y, screenWindow.max()[1], 6 ) # For perspective cameras, we set a FOV value that drives the effective screen window. # As long as pixels aren't distorted, and there is no aperture offset, # applying Arnold's automatic screen window computation to a default screen window # should give us the correct result self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_min" ).x, -1.0 ) self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_min" ).y, -1.0 ) self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_max" ).x, 1.0 ) self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_max" ).y, 1.0 )
def testPrimitiveVariables( self ) : s = IECore.SpherePrimitive() s["v"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.V3f( 1, 2, 3 ) ) s["c"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.Color3f( 1, 2, 3 ) ) s["s"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, "test" ) s["i"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, 11 ) s["b"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, True ) s["f"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, 2.5 ) s["m"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.M44f( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( s, "testSphere" ) self.assertEqual( arnold.AiNodeGetVec( n, "v" ), arnold.AtVector( 1, 2, 3 ) ) self.assertEqual( arnold.AiNodeGetRGB( n, "c" ), arnold.AtRGB( 1, 2, 3 ) ) self.assertEqual( arnold.AiNodeGetStr( n, "s" ), "test" ) self.assertEqual( arnold.AiNodeGetInt( n, "i" ), 11 ) self.assertEqual( arnold.AiNodeGetBool( n, "b" ), True ) self.assertEqual( arnold.AiNodeGetFlt( n, "f" ), 2.5 ) m = arnold.AiNodeGetMatrix( n, "m" ) self.assertEqual( [ list( i ) for i in m.data ], [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16] ], )
def testConvert( self ) : s = IECore.SpherePrimitive( 0.25 ) with IECoreArnold.UniverseBlock() : n = IECoreArnold.NodeAlgo.convert( s ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) self.assertEqual( arnold.AiNodeGetFlt( n, "radius" ), 0.25 )
def testConvert( self ) : s = IECoreScene.SpherePrimitive( 0.25 ) with IECoreArnold.UniverseBlock( writable = True ) as universe : n = IECoreArnold.NodeAlgo.convert( s, universe, "testSphere" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) self.assertEqual( arnold.AiNodeGetFlt( n, "radius" ), 0.25 )
def testConvertCustomProjection(self): with IECoreArnold.UniverseBlock(writable=True): n = IECoreArnold.NodeAlgo.convert( IECoreScene.Camera( parameters={ "projection": "cyl_camera", "horizontal_fov": 45.0, "vertical_fov": 80.0, }), "testCamera") self.assertTrue( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n)), "cyl_camera") self.assertEqual(arnold.AiNodeGetFlt(n, "horizontal_fov"), 45.0) self.assertEqual(arnold.AiNodeGetFlt(n, "vertical_fov"), 80.0)
def testBlindData(self): flat = IECoreScene.Shader("flat") flat.blindData().update({ "user:testInt": IECore.IntData(1), "user:testFloat": IECore.FloatData(2.5), "user:testV3f": IECore.V3fData(imath.V3f(1, 2, 3)), "user:testColor3f": IECore.Color3fData(imath.Color3f(4, 5, 6)), "user:testString": IECore.StringData("we're all doomed"), }) network = IECoreScene.ShaderNetwork(shaders={ "noiseHandle": IECoreScene.Shader("noise"), "flatHandle": flat, }, connections=[ (("noiseHandle", ""), ("flatHandle", "color")), ], output="flatHandle") with IECoreArnold.UniverseBlock(writable=True) as universe: nodes = IECoreArnoldPreview.ShaderNetworkAlgo.convert( network, universe, "test") self.assertEqual(len(nodes), 2) self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(nodes[0])), "noise") self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(nodes[1])), "flat") self.assertEqual(arnold.AiNodeGetName(nodes[0]), "test:noiseHandle") self.assertEqual(arnold.AiNodeGetName(nodes[1]), "test") self.assertEqual(arnold.AiNodeGetInt(nodes[1], "user:testInt"), 1) self.assertEqual(arnold.AiNodeGetFlt(nodes[1], "user:testFloat"), 2.5) self.assertEqual(arnold.AiNodeGetVec(nodes[1], "user:testV3f"), arnold.AtVector(1, 2, 3)) self.assertEqual(arnold.AiNodeGetRGB(nodes[1], "user:testColor3f"), arnold.AtRGB(4, 5, 6)) self.assertEqual(arnold.AiNodeGetStr(nodes[1], "user:testString"), "we're all doomed")
def testSetParameter( self ) : with IECoreArnold.UniverseBlock( writable = True ) : n = arnold.AiNode( "standard_surface" ) IECoreArnold.ParameterAlgo.setParameter( n, "base", IECore.FloatData( 0.25 ) ) IECoreArnold.ParameterAlgo.setParameter( n, "customString", IECore.StringData( "test" ) ) self.assertEqual( arnold.AiNodeGetFlt( n, "base" ), 0.25 ) self.assertEqual( arnold.AiNodeGetStr( n, "customString" ), "test" )
def testMotion(self): m1 = IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(-1), IECore.V2f(1))) IECore.MeshNormalsOp()(input=m1, copyInput=False) m2 = m1.copy() m2["P"].data[0] -= IECore.V3f(0, 0, 1) m2["P"].data[1] -= IECore.V3f(0, 0, 1) IECore.MeshNormalsOp()(input=m2, copyInput=False) with IECoreArnold.UniverseBlock(writable=True): node = IECoreArnold.NodeAlgo.convert([m1, m2], -0.25, 0.25, "testMesh") vList = arnold.AiNodeGetArray(node, "vlist") self.assertEqual(arnold.AiArrayGetNumElements(vList.contents), 4) self.assertEqual(arnold.AiArrayGetNumKeys(vList.contents), 2) nList = arnold.AiNodeGetArray(node, "nlist") self.assertEqual(arnold.AiArrayGetNumElements(nList.contents), 4) self.assertEqual(arnold.AiArrayGetNumKeys(nList.contents), 2) for i in range(0, 4): p = arnold.AiArrayGetVec(vList, i) self.assertEqual(IECore.V3f(p.x, p.y, p.z), m1["P"].data[i]) n = arnold.AiArrayGetVec(nList, i) self.assertEqual(IECore.V3f(n.x, n.y, n.z), m1["N"].data[i]) for i in range(4, 8): p = arnold.AiArrayGetVec(vList, i) self.assertEqual(IECore.V3f(p.x, p.y, p.z), m2["P"].data[i - 4]) n = arnold.AiArrayGetVec(nList, i) self.assertEqual(IECore.V3f(n.x, n.y, n.z), m2["N"].data[i - 4]) self.assertEqual(arnold.AiNodeGetFlt(node, "motion_start"), -0.25) self.assertEqual(arnold.AiNodeGetFlt(node, "motion_end"), 0.25)
def testSetParameter(self): with IECoreArnold.UniverseBlock(writable=True): n = arnold.AiNode("standard") IECoreArnold.ParameterAlgo.setParameter(n, "Kd", IECore.FloatData(0.25)) IECoreArnold.ParameterAlgo.setParameter(n, "aov_emission", IECore.StringData("test")) self.assertEqual(arnold.AiNodeGetFlt(n, "Kd"), 0.25) self.assertEqual(arnold.AiNodeGetStr(n, "aov_emission"), "test")
def testGetParameter(self): with IECoreArnold.UniverseBlock(writable=True): n = arnold.AiNode("standard") self.assertEqual(IECoreArnold.ParameterAlgo.getParameter(n, "Kd"), IECore.FloatData(arnold.AiNodeGetFlt(n, "Kd"))) self.assertEqual( IECoreArnold.ParameterAlgo.getParameter(n, "aov_emission"), IECore.StringData("emission"), )
def testGetParameter(self): with IECoreArnold.UniverseBlock(writable=True): n = arnold.AiNode("standard_surface") self.assertEqual( IECoreArnold.ParameterAlgo.getParameter(n, "base"), IECore.FloatData(arnold.AiNodeGetFlt(n, "base"))) IECore.FloatData(arnold.AiNodeSetStr(n, "name", "testString")) self.assertEqual( IECoreArnold.ParameterAlgo.getParameter(n, "name"), IECore.StringData("testString"), )
def Init(procName): proc = arnold.AiNodeLookUpByName(procName) if not proc: print("No such procedural: %s" % procName) return (0, None) attrs = {} it = arnold.AiNodeGetUserParamIterator(proc) while not arnold.AiUserParamIteratorFinished(it): param = arnold.AiUserParamIteratorGetNext(it) pname = arnold.AiUserParamGetName(param) pcat = arnold.AiUserParamGetCategory(param) if pcat == arnold.AI_USERDEF_CONSTANT: ptype = arnold.AiUserParamGetType(param) pval = None if ptype == arnold.AI_TYPE_BOOLEAN: pval = arnold.AiNodeGetBool(proc, pname) elif ptype == arnold.AI_TYPE_INT: pval = arnold.AiNodeGetInt(proc, pname) elif ptype == arnold.AI_TYPE_UINT: pval = arnold.AiNodeGetUInt(proc, pname) elif ptype == arnold.AI_TYPE_FLOAT: pval = arnold.AiNodeGetFlt(proc, pname) elif ptype == arnold.AI_TYPE_POINT: pval = arnold.AiNodeGetPnt(proc, pname) elif ptype == arnold.AI_TYPE_POINT2: pval = arnold.AiNodeGetPnt2(proc, pname) elif ptype == arnold.AI_TYPE_VECTOR: pval = arnold.AiNodeGetVec(proc, pname) elif ptype == arnold.AI_TYPE_RGB: pval = arnold.AiNodeGetRGB(proc, pname) elif ptype == arnold.AI_TYPE_RGBA: pval = arnold.AiNodeGetRGBA(proc, pname) elif ptype == arnold.AI_TYPE_STRING: pval = arnold.AiNodeGetStr(proc, pname) if pval != None: attrs[pname] = (ptype, pval) else: print("Unsupported type (%d) for parameter \"%s\"" % (ptype, pname)) else: print("Ignore non constant parameter \"%s\"" % pname) arnold.AiUserParamIteratorFinished(it) return (1, attrs)
def testProcedural( self ) : r = IECoreArnold.Renderer( "/tmp/test.ass" ) with IECore.WorldBlock( r ) : # In Arnold 5, external procedurals register node types that look just like the built-in # ones. So we need to be able to use ExternalProcedural to create an arbitrary node type, # instead of passing in a filename. Test with a volume, because this node type exists by default. r.procedural( r.ExternalProcedural( "volume", IECore.Box3f( IECore.V3f( -1, -2, -3 ), IECore.V3f( 4, 5, 6 ) ), { "testFloat" : 0.5 } ) ) volume = self.__allNodes( type = arnold.AI_NODE_SHAPE )[-1] self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( volume ) ), "volume" ) self.assertEqual( arnold.AiNodeGetFlt( volume, "testFloat" ), 0.5 )
def testConvertPerspective( self ) : with IECoreArnold.UniverseBlock( writable = True ) : c = IECoreScene.Camera( parameters = { "projection" : "perspective", "focalLength" : 1 / ( 2.0 * math.tan( 0.5 * math.radians( 45 ) ) ), "resolution" : imath.V2i( 512 ), "aperture" : imath.V2f( 2, 1 ) } ) n = IECoreArnold.NodeAlgo.convert( c, "testCamera" ) screenWindow = c.frustum() self.assertTrue( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "persp_camera" ) screenWindowMult = math.tan( 0.5 * math.radians( arnold.AiNodeGetFlt( n, "fov" ) ) ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).x, screenWindow.min()[0] ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).y, screenWindow.min()[1] ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).x, screenWindow.max()[0] ) self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).y, screenWindow.max()[1] )
def testTransformMotion( self ) : s = Gaffer.ScriptNode() s["plane"] = GafferScene.Plane() s["sphere"] = GafferScene.Sphere() s["group"] = GafferScene.Group() s["group"]["in"][0].setInput( s["plane"]["out"] ) s["group"]["in"][1].setInput( s["sphere"]["out"] ) s["expression"] = Gaffer.Expression() s["expression"].setExpression( inspect.cleandoc( """ parent["plane"]["transform"]["translate"]["x"] = context.getFrame() parent["sphere"]["transform"]["translate"]["y"] = context.getFrame() * 2 parent["group"]["transform"]["translate"]["z"] = context.getFrame() - 1 """ ) ) s["planeFilter"] = GafferScene.PathFilter() s["planeFilter"]["paths"].setValue( IECore.StringVectorData( [ "/group/plane" ] ) ) s["attributes"] = GafferScene.StandardAttributes() s["attributes"]["in"].setInput( s["group"]["out"] ) s["attributes"]["filter"].setInput( s["planeFilter"]["out"] ) s["attributes"]["attributes"]["transformBlur"]["enabled"].setValue( True ) s["attributes"]["attributes"]["transformBlur"]["value"].setValue( False ) s["options"] = GafferScene.StandardOptions() s["options"]["in"].setInput( s["attributes"]["out"] ) s["options"]["options"]["shutter"]["enabled"].setValue( True ) s["options"]["options"]["transformBlur"]["enabled"].setValue( True ) s["render"] = GafferArnold.ArnoldRender() s["render"]["in"].setInput( s["options"]["out"] ) s["render"]["mode"].setValue( s["render"].Mode.SceneDescriptionMode ) s["render"]["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) # No motion blur s["options"]["options"]["transformBlur"]["value"].setValue( False ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) camera = arnold.AiNodeLookUpByName( "gaffer:defaultCamera" ) sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) sphereMotionStart = arnold.AiNodeGetFlt( sphere, "motion_start" ) sphereMotionEnd = arnold.AiNodeGetFlt( sphere, "motion_end" ) sphereMatrix = arnold.AiNodeGetMatrix( sphere, "matrix" ) plane = arnold.AiNodeLookUpByName( "/group/plane" ) planeMotionStart = arnold.AiNodeGetFlt( plane, "motion_start" ) planeMotionEnd = arnold.AiNodeGetFlt( plane, "motion_end" ) planeMatrix = arnold.AiNodeGetMatrix( plane, "matrix" ) # Motion parameters should be left at default self.assertEqual( sphereMotionStart, 0 ) self.assertEqual( sphereMotionEnd, 1 ) self.assertEqual( planeMotionStart, 0 ) self.assertEqual( planeMotionEnd, 1 ) expectedSphereMatrix = arnold.AiM4Translation( arnold.AtVector( 0, 2, 0 ) ) expectedPlaneMatrix = arnold.AiM4Translation( arnold.AtVector( 1, 0, 0 ) ) self.assertEqual( self.__m44f( sphereMatrix ), self.__m44f( expectedSphereMatrix ) ) self.assertEqual( self.__m44f( planeMatrix ), self.__m44f( expectedPlaneMatrix ) ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_start" ), 1 ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_end" ), 1 ) # Motion blur s["options"]["options"]["transformBlur"]["value"].setValue( True ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) camera = arnold.AiNodeLookUpByName( "gaffer:defaultCamera" ) sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) sphereMotionStart = arnold.AiNodeGetFlt( sphere, "motion_start" ) sphereMotionEnd = arnold.AiNodeGetFlt( sphere, "motion_end" ) sphereMatrices = arnold.AiNodeGetArray( sphere, "matrix" ) plane = arnold.AiNodeLookUpByName( "/group/plane" ) planeMotionStart = arnold.AiNodeGetFlt( plane, "motion_start" ) planeMotionEnd = arnold.AiNodeGetFlt( plane, "motion_end" ) planeMatrices = arnold.AiNodeGetArray( plane, "matrix" ) self.assertEqual( sphereMotionStart, 0.75 ) self.assertEqual( sphereMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( sphereMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( sphereMatrices.contents ), 2 ) self.assertEqual( planeMotionStart, 0.75 ) self.assertEqual( planeMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( planeMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( planeMatrices.contents ), 2 ) for i in range( 0, 2 ) : frame = 0.75 + 0.5 * i sphereMatrix = arnold.AiArrayGetMtx( sphereMatrices, i ) expectedSphereMatrix = arnold.AiM4Translation( arnold.AtVector( 0, frame * 2, frame - 1 ) ) planeMatrix = arnold.AiArrayGetMtx( planeMatrices, i ) expectedPlaneMatrix = arnold.AiM4Translation( arnold.AtVector( 1, 0, frame - 1 ) ) self.assertEqual( self.__m44f( sphereMatrix ), self.__m44f( expectedSphereMatrix ) ) self.assertEqual( self.__m44f( planeMatrix ), self.__m44f( expectedPlaneMatrix ) ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_start" ), 0.75 ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_end" ), 1.25 ) # Motion blur on, but sampleMotion off s["options"]["options"]["sampleMotion"]["enabled"].setValue( True ) s["options"]["options"]["sampleMotion"]["value"].setValue( False ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) camera = arnold.AiNodeLookUpByName( "gaffer:defaultCamera" ) sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) sphereMotionStart = arnold.AiNodeGetFlt( sphere, "motion_start" ) sphereMotionEnd = arnold.AiNodeGetFlt( sphere, "motion_end" ) sphereMatrices = arnold.AiNodeGetArray( sphere, "matrix" ) plane = arnold.AiNodeLookUpByName( "/group/plane" ) planeMotionStart = arnold.AiNodeGetFlt( plane, "motion_start" ) planeMotionEnd = arnold.AiNodeGetFlt( plane, "motion_end" ) planeMatrices = arnold.AiNodeGetArray( plane, "matrix" ) self.assertEqual( sphereMotionStart, 0.75 ) self.assertEqual( sphereMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( sphereMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( sphereMatrices.contents ), 2 ) self.assertEqual( planeMotionStart, 0.75 ) self.assertEqual( planeMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( planeMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( planeMatrices.contents ), 2 ) for i in range( 0, 2 ) : frame = 0.75 + 0.5 * i sphereMatrix = arnold.AiArrayGetMtx( sphereMatrices, i ) expectedSphereMatrix = arnold.AiM4Translation( arnold.AtVector( 0, frame * 2, frame - 1 ) ) planeMatrix = arnold.AiArrayGetMtx( planeMatrices, i ) expectedPlaneMatrix = arnold.AiM4Translation( arnold.AtVector( 1, 0, frame - 1 ) ) self.assertEqual( self.__m44f( sphereMatrix ), self.__m44f( expectedSphereMatrix ) ) self.assertEqual( self.__m44f( planeMatrix ), self.__m44f( expectedPlaneMatrix ) ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_start" ), 0.75 ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_end" ), 0.75 )
def testConvertAnimatedParameters(self): with IECoreArnold.UniverseBlock(writable=True): samples = [] for i in range(0, 2): camera = IECoreScene.Camera() camera.setProjection("perspective") camera.setFocalLengthFromFieldOfView(45 * (i + 1)) camera.setAperture(imath.V2f(10, 10 + i)) camera.setFStop(i + 1) camera.setFocusDistance(i + 100) samples.append(camera) animatedNode = IECoreArnold.NodeAlgo.convert( samples, 1.0, 2.0, "samples") nodes = [ IECoreArnold.NodeAlgo.convert(samples[i], "sample{}".format(i)) for i, sample in enumerate(samples) ] self.assertEqual(arnold.AiNodeGetFlt(animatedNode, "motion_start"), 1.0) self.assertEqual(arnold.AiNodeGetFlt(animatedNode, "motion_start"), 1.0) for i, node in enumerate(nodes): animatedScreenWindowMin = arnold.AiArrayGetVec2( arnold.AiNodeGetArray(animatedNode, "screen_window_min"), i) animatedScreenWindowMax = arnold.AiArrayGetVec2( arnold.AiNodeGetArray(animatedNode, "screen_window_max"), i) self.assertEqual( animatedScreenWindowMin.x, arnold.AiNodeGetVec2(node, "screen_window_min").x) self.assertEqual( animatedScreenWindowMin.y, arnold.AiNodeGetVec2(node, "screen_window_min").y) self.assertEqual( animatedScreenWindowMax.x, arnold.AiNodeGetVec2(node, "screen_window_max").x) self.assertEqual( animatedScreenWindowMax.y, arnold.AiNodeGetVec2(node, "screen_window_max").y) self.assertEqual( arnold.AiArrayGetFlt( arnold.AiNodeGetArray(animatedNode, "fov"), i), arnold.AiNodeGetFlt(node, "fov")) self.assertEqual( arnold.AiArrayGetFlt( arnold.AiNodeGetArray(animatedNode, "aperture_size"), i), arnold.AiNodeGetFlt(node, "aperture_size")) self.assertEqual( arnold.AiArrayGetFlt( arnold.AiNodeGetArray(animatedNode, "focus_distance"), i), arnold.AiNodeGetFlt(node, "focus_distance")) for parameter in [ "screen_window_min", "screen_window_max", "fov", "aperture_size", "focus_distance", ]: array = arnold.AiNodeGetArray(animatedNode, "fov") self.assertEqual(arnold.AiArrayGetNumElements(array), 1) self.assertEqual(arnold.AiArrayGetNumKeys(array), 2)
def testOldRandomCamera(self): random.seed(42) with IECoreArnold.UniverseBlock(writable=True): for i in range(40): resolution = imath.V2i(random.randint(10, 1000), random.randint(10, 1000)) pixelAspectRatio = random.uniform(0.5, 2) screenWindow = imath.Box2f( imath.V2f(-random.uniform(0, 2), -random.uniform(0, 2)), imath.V2f(random.uniform(0, 2), random.uniform(0, 2))) screenWindowAspectScale = imath.V2f( 1.0, (screenWindow.size()[0] / screenWindow.size()[1]) * (resolution[1] / float(resolution[0])) / pixelAspectRatio) screenWindow.setMin(screenWindow.min() * screenWindowAspectScale) screenWindow.setMax(screenWindow.max() * screenWindowAspectScale) c = IECoreScene.Camera( parameters={ "projection": "orthographic" if random.random() > 0.5 else "perspective", "projection:fov": random.uniform(1, 100), "clippingPlanes": imath.V2f(random.uniform(0.001, 100)) + imath.V2f(0, random.uniform(0, 1000)), "resolution": resolution, "pixelAspectRatio": pixelAspectRatio }) if i < 20: c.parameters()["screenWindow"] = screenWindow n = IECoreArnold.NodeAlgo.convert(c, "testCamera") arnoldType = "persp_camera" if c.parameters()["projection"].value == "orthographic": arnoldType = "ortho_camera" self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n)), arnoldType) cortexClip = c.parameters()["clippingPlanes"].value self.assertEqual(arnold.AiNodeGetFlt(n, "near_clip"), cortexClip[0]) self.assertEqual(arnold.AiNodeGetFlt(n, "far_clip"), cortexClip[1]) resolution = c.parameters()["resolution"].value aspect = c.parameters( )["pixelAspectRatio"].value * resolution.x / float( resolution.y) if "screenWindow" in c.parameters(): cortexWindow = c.parameters()["screenWindow"].value else: if aspect > 1.0: cortexWindow = imath.Box2f(imath.V2f(-aspect, -1), imath.V2f(aspect, 1)) else: cortexWindow = imath.Box2f(imath.V2f(-1, -1 / aspect), imath.V2f(1, 1 / aspect)) if c.parameters()["projection"].value != "orthographic": windowScale = math.tan( math.radians(0.5 * arnold.AiNodeGetFlt(n, "fov"))) cortexWindowScale = math.tan( math.radians(0.5 * c.parameters()["projection:fov"].value)) else: windowScale = 1.0 cortexWindowScale = 1.0 self.assertAlmostEqual( windowScale * arnold.AiNodeGetVec2(n, "screen_window_min").x, cortexWindowScale * cortexWindow.min()[0], places=4) self.assertAlmostEqual( windowScale * arnold.AiNodeGetVec2(n, "screen_window_min").y, cortexWindowScale * cortexWindow.min()[1] * aspect, places=4) self.assertAlmostEqual( windowScale * arnold.AiNodeGetVec2(n, "screen_window_max").x, cortexWindowScale * cortexWindow.max()[0], places=4) self.assertAlmostEqual( windowScale * arnold.AiNodeGetVec2(n, "screen_window_max").y, cortexWindowScale * cortexWindow.max()[1] * aspect, places=4) if c.parameters()["projection"].value == "perspective": self.assertAlmostEqual( arnold.AiNodeGetVec2(n, "screen_window_max").x - arnold.AiNodeGetVec2(n, "screen_window_min").x, 2.0, places=6) self.assertAlmostEqual( arnold.AiNodeGetVec2(n, "screen_window_max").y - arnold.AiNodeGetVec2(n, "screen_window_min").y, 2.0, places=6)