def testNormals(self): m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-0.9), imath.V2f(0.9))) m["N"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([ imath.V3f(1, 0, 0), imath.V3f(1, 0, 0), imath.V3f(1, 0, 0), imath.V3f(1, 0, 0) ])) mFaceVaryingIndexed = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(-0.9), imath.V3f(0.9))) mVertexIndexed = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-0.9), imath.V2f(0.9)), imath.V2i(3)) mVertexIndexed["N"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([imath.V3f(1, 0, 0), imath.V3f(-1, 0, 0)]), IECore.IntVectorData([0] * 8 + [1] * 8)) with IECoreArnold.UniverseBlock(writable=True): n = IECoreArnold.NodeAlgo.convert(m, "testMesh") normals = arnold.AiNodeGetArray(n, "nlist") self.assertEqual(arnold.AiArrayGetNumElements(normals.contents), 4) for i in range(0, 4): self.assertEqual(arnold.AiArrayGetVec(normals, i), arnold.AtVector(1, 0, 0)) n = IECoreArnold.NodeAlgo.convert(mFaceVaryingIndexed, "testMesh2") normals = arnold.AiNodeGetArray(n, "nlist") normalIndices = arnold.AiNodeGetArray(n, "nidxs") refNormals = [(0, 0, -1), (1, 0, 0), (0, 0, 1), (-1, 0, 0), (0, 1, 0), (0, -1, 0)] for i in range(0, 24): self.assertEqual( arnold.AiArrayGetVec( normals, arnold.AiArrayGetInt(normalIndices, i)), arnold.AtVector(*refNormals[i / 4])) n = IECoreArnold.NodeAlgo.convert(mVertexIndexed, "testMesh3") normals = arnold.AiNodeGetArray(n, "nlist") normalIndices = arnold.AiNodeGetArray(n, "nidxs") for i in range(0, 36): s = [0, (i / 2) % 2, 1][i / 12] self.assertEqual( arnold.AiArrayGetVec( normals, arnold.AiArrayGetInt(normalIndices, i)), arnold.AtVector(-1 if s else 1, 0, 0))
def testTraceSets(self): sphere = GafferScene.Sphere() group = GafferScene.Group() group["in"][0].setInput(sphere["out"]) group["in"][1].setInput(sphere["out"]) set1 = GafferScene.Set() set1["name"].setValue("render:firstSphere") set1["paths"].setValue(IECore.StringVectorData(["/group/sphere"])) set1["in"].setInput(group["out"]) set2 = GafferScene.Set() set2["name"].setValue("render:secondSphere") set2["paths"].setValue(IECore.StringVectorData(["/group/sphere1"])) set2["in"].setInput(set1["out"]) set3 = GafferScene.Set() set3["name"].setValue("render:group") set3["paths"].setValue(IECore.StringVectorData(["/group"])) set3["in"].setInput(set2["out"]) set4 = GafferScene.Set() set4["name"].setValue("render:bothSpheres") set4["paths"].setValue( IECore.StringVectorData(["/group/sphere", "/group/sphere1"])) set4["in"].setInput(set3["out"]) render = GafferArnold.ArnoldRender() render["in"].setInput(set4["out"]) render["mode"].setValue(render.Mode.SceneDescriptionMode) render["fileName"].setValue(self.temporaryDirectory() + "/test.ass") render["task"].execute() with IECoreArnold.UniverseBlock(writable=True): arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass") firstSphere = arnold.AiNodeLookUpByName("/group/sphere") secondSphere = arnold.AiNodeLookUpByName("/group/sphere1") self.assertEqual( self.__arrayToSet( arnold.AiNodeGetArray(firstSphere, "trace_sets")), {"firstSphere", "group", "bothSpheres"}) self.assertEqual( self.__arrayToSet( arnold.AiNodeGetArray(secondSphere, "trace_sets")), {"secondSphere", "group", "bothSpheres"})
def testConvertShutterCurve(self): with IECoreArnold.UniverseBlock(writable=True): camera = IECoreScene.Camera() camera.setProjection("perspective") camera.parameters()["shutter_curve"] = IECore.Splineff( IECore.CubicBasisf.linear(), [ (0, -0.1), (0.25, 1), (0.75, 1.1), (1.1, 0), ], ) node = IECoreArnold.NodeAlgo.convert(camera, "camera") curve = arnold.AiNodeGetArray(node, "shutter_curve") self.assertEqual(arnold.AiArrayGetNumElements(curve), 4) self.assertEqual(arnold.AiArrayGetVec2(curve, 0), arnold.AtVector2(0, 0)) self.assertEqual(arnold.AiArrayGetVec2(curve, 1), arnold.AtVector2(0.25, 1)) self.assertEqual(arnold.AiArrayGetVec2(curve, 2), arnold.AtVector2(0.75, 1)) self.assertEqual(arnold.AiArrayGetVec2(curve, 3), arnold.AtVector2(1, 0)) camera.parameters()["shutter_curve"] = IECore.Splineff( IECore.CubicBasisf.catmullRom(), [ (0, 0), (0, 0), (0.25, 1), (0.75, 1), (1, 0), (1, 0), ], ) node = IECoreArnold.NodeAlgo.convert(camera, "camera") curve = arnold.AiNodeGetArray(node, "shutter_curve") self.assertEqual(arnold.AiArrayGetNumElements(curve), 25) for i in range(0, 25): point = arnold.AiArrayGetVec2(curve, i) self.assertAlmostEqual(min( camera.parameters()["shutter_curve"].value(point.x), 1), point.y, delta=0.0001)
def testNPrimitiveVariable( self ) : c = IECore.CurvesPrimitive( IECore.IntVectorData( [ 4 ] ), IECore.CubicBasisf.catmullRom() ) c["P"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( x, 0, 0 ) for x in range( 0, 4 ) ] ) ) with IECoreArnold.UniverseBlock( writable = True ) : # No N - should be a ribbon n = IECoreArnold.NodeAlgo.convert( c, "testCurve" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "ribbon" ) self.assertEqual( arnold.AiArrayGetNumElements( arnold.AiNodeGetArray( n, "orientations" ).contents ), 0 ) # N - should be oriented c["N"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( 0, math.sin( x ), math.cos( x ) ) for x in range( 0, 4 ) ] ) ) n = IECoreArnold.NodeAlgo.convert( c, "testCurve" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "oriented" ) orientations = arnold.AiNodeGetArray( n, "orientations" ) self.assertEqual( arnold.AiArrayGetNumElements( orientations.contents ), 4 ) for i in range( 0, 4 ) : self.assertEqual( arnold.AiArrayGetVec( orientations, i ), arnold.AtVector( 0, math.sin( i ), math.cos( i ) ) ) # Motion blurred N - should be oriented and deforming c2 = c.copy() c2["N"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ IECore.V3f( 0, math.sin( x + 0.2 ), math.cos( x + 0.2 ) ) for x in range( 0, 4 ) ] ) ) n = IECoreArnold.NodeAlgo.convert( [ c, c2 ], 0.0, 1.0, "testCurve" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "oriented" ) orientations = arnold.AiNodeGetArray( n, "orientations" ) self.assertEqual( arnold.AiArrayGetNumElements( orientations.contents ), 4 ) self.assertEqual( arnold.AiArrayGetNumKeys( orientations.contents ), 2 ) for i in range( 0, 4 ) : self.assertEqual( arnold.AiArrayGetVec( orientations, i ), arnold.AtVector( 0, math.sin( i ), math.cos( i ) ) ) self.assertEqual( arnold.AiArrayGetVec( orientations, i + 4 ), arnold.AtVector( 0, math.sin( i + 0.2 ), math.cos( i + 0.2 ) ) )
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 testConvertWithMotion( self ) : s = [ IECore.SpherePrimitive( 0.25 ), IECore.SpherePrimitive( 0.5 ) ] with IECoreArnold.UniverseBlock() : n = IECoreArnold.NodeAlgo.convert( s, [ 0, 1 ] ) 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 ) a = arnold.AiNodeGetArray( n, "deform_time_samples" ) self.assertEqual( arnold.AiArrayGetFlt( a, 0 ), 0 ) self.assertEqual( arnold.AiArrayGetFlt( a, 1 ), 1 )
def testVertexUVs(self): c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([2, 2]), IECore.CubicBasisf.linear()) c["P"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([imath.V3f(x, 0, 0) for x in range(0, 4)])) c["uv"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V2fVectorData([ imath.V2f(1, 2), imath.V2f(3, 4), imath.V2f(5, 6), imath.V2f(7, 8), ], IECore.GeometricData.Interpretation.UV)) with IECoreArnold.UniverseBlock(writable=True) as universe: n = IECoreArnold.NodeAlgo.convert(c, universe, "testCurve") uvs = arnold.AiNodeGetArray(n, "uvs").contents self.assertEqual(arnold.AiArrayGetNumElements(uvs), 4) self.assertEqual(arnold.AiArrayGetVec2(uvs, 0), arnold.AtVector2(1, 2)) self.assertEqual(arnold.AiArrayGetVec2(uvs, 1), arnold.AtVector2(3, 4)) self.assertEqual(arnold.AiArrayGetVec2(uvs, 2), arnold.AtVector2(5, 6)) self.assertEqual(arnold.AiArrayGetVec2(uvs, 3), arnold.AtVector2(7, 8))
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) as universe: n = IECoreArnold.NodeAlgo.convert(m, universe, "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 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) as universe: n = IECoreArnold.NodeAlgo.convert(m, universe, "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 testLightFilters(self): s = Gaffer.ScriptNode() s["lightFilter"] = GafferArnold.ArnoldLightFilter() s["lightFilter"].loadShader("light_blocker") s["attributes"] = GafferScene.StandardAttributes() s["attributes"]["in"].setInput(s["lightFilter"]["out"]) s["attributes"]["attributes"]["filteredLights"]["enabled"].setValue( True) s["attributes"]["attributes"]["filteredLights"]["value"].setValue( "defaultLights") s["light"] = GafferArnold.ArnoldLight() s["light"].loadShader("point_light") s["gobo"] = GafferArnold.ArnoldShader() s["gobo"].loadShader("gobo") s["assignment"] = GafferScene.ShaderAssignment() s["assignment"]["in"].setInput(s["light"]["out"]) s["assignment"]["shader"].setInput(s["gobo"]["out"]) s["group"] = GafferScene.Group() s["group"]["in"][0].setInput(s["attributes"]["out"]) s["group"]["in"][1].setInput(s["assignment"]["out"]) s["render"] = GafferArnold.ArnoldRender() s["render"]["in"].setInput(s["group"]["out"]) s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode) s["render"]["fileName"].setValue(self.temporaryDirectory() + "/test.ass") s["render"]["task"].execute() with IECoreArnold.UniverseBlock(writable=True): arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass") light = arnold.AiNodeLookUpByName("light:/group/light") linkedFilters = arnold.AiNodeGetArray(light, "filters") numFilters = arnold.AiArrayGetNumElements(linkedFilters.contents) self.assertEqual(numFilters, 2) linkedFilter = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 0), arnold.POINTER(arnold.AtNode)) linkedGobo = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 1), arnold.POINTER(arnold.AtNode)) self.assertEqual(arnold.AiNodeGetName(linkedFilter), "lightFilter:/group/lightFilter") self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry(linkedFilter)), "light_blocker") self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry(linkedGobo)), "gobo")
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 testPointTypePrimitiveVariables( self ) : # make sure that we can add prim vars of both vector and point type, and differentiate between the two. m = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) ) points = IECore.V3fVectorData( [] ) IECore.setGeometricInterpretation( points, IECore.GeometricData.Interpretation.Point ) m["points"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, points ) vectors = IECore.V3fVectorData( [] ) IECore.setGeometricInterpretation( vectors, IECore.GeometricData.Interpretation.Vector ) m["vectors"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, vectors ) with IECoreArnold.UniverseBlock( writable = True ) : node = IECoreArnold.NodeAlgo.convert( m ) p = arnold.AiNodeGetArray( node, "points" ) self.assertEqual( p.contents.type, arnold.AI_TYPE_POINT ) v = arnold.AiNodeGetArray( node, "vectors" ) self.assertEqual( v.contents.type, arnold.AI_TYPE_VECTOR )
def testUVs( self ) : m = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) ) uvData = m["uv"].data with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( m ) uvs = arnold.AiNodeGetArray( n, "uvlist" ) self.assertEqual( uvs.contents.nelements, 4 ) uvIndices = arnold.AiNodeGetArray( n, "uvidxs" ) self.assertEqual( uvIndices.contents.nelements, 4 ) for i in range( 0, 4 ) : p = arnold.AiArrayGetPnt2( uvs, i ) self.assertEqual( arnold.AiArrayGetPnt2( uvs, i ), arnold.AtPoint2( uvData[i][0], uvData[i][1] ) ) self.assertEqual( arnold.AiArrayGetInt( uvIndices, i ), i )
def testLightFiltersMany(self): # \todo: this can easily be turned into a performance test s = Gaffer.ScriptNode() s["lightFilter"] = GafferArnold.ArnoldLightFilter() s["lightFilter"].loadShader("light_blocker") s["lightFilter"]["filteredLights"].setValue("defaultLights") s["planeFilters"] = GafferScene.Plane("Plane") s["planeFilters"]["divisions"].setValue(imath.V2i(9)) s["instancerFilters"] = GafferScene.Instancer("Instancer") s["instancerFilters"]["in"].setInput(s["planeFilters"]["out"]) s["instancerFilters"]["instances"].setInput(s["lightFilter"]["out"]) s["instancerFilters"]["parent"].setValue("/plane") s["light"] = GafferArnold.ArnoldLight() s["light"].loadShader("point_light") s["planeLights"] = GafferScene.Plane("Plane") s["planeLights"]["divisions"].setValue(imath.V2i(9)) s["instancerLights"] = GafferScene.Instancer("Instancer") s["instancerLights"]["in"].setInput(s["planeLights"]["out"]) s["instancerLights"]["instances"].setInput(s["light"]["out"]) s["instancerLights"]["parent"].setValue("/plane") s["group"] = GafferScene.Group("Group") s["group"]["in"][0].setInput(s["instancerFilters"]["out"]) s["group"]["in"][1].setInput(s["instancerLights"]["out"]) s["render"] = GafferArnold.ArnoldRender() s["render"]["in"].setInput(s["group"]["out"]) s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode) s["render"]["fileName"].setValue(self.temporaryDirectory() + "/testMany.ass") s["render"]["task"].execute() with IECoreArnold.UniverseBlock(writable=True): foo = self.temporaryDirectory() + "/testMany.ass" print foo arnold.AiASSLoad(foo) for i in range(100): light = arnold.AiNodeLookUpByName( "light:/group/plane1/instances/light/%s" % i) linkedFilters = arnold.AiNodeGetArray(light, "filters") numFilters = arnold.AiArrayGetNumElements( linkedFilters.contents) self.assertEqual(numFilters, 100)
def testMotion(self): p1 = IECore.PointsPrimitive(IECore.V3fVectorData([IECore.V3f(10)] * 10)) p1["width"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData([1] * 10), ) p2 = IECore.PointsPrimitive(IECore.V3fVectorData([IECore.V3f(20)] * 10)) p2["width"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData([2] * 10), ) with IECoreArnold.UniverseBlock(writable=True): n = IECoreArnold.NodeAlgo.convert([p1, p2], [-0.25, 0.25]) a = arnold.AiNodeGetArray(n, "points") self.assertEqual(a.contents.nelements, 10) self.assertEqual(a.contents.nkeys, 2) r = arnold.AiNodeGetArray(n, "radius") self.assertEqual(a.contents.nelements, 10) self.assertEqual(a.contents.nkeys, 2) for i in range(0, 10): self.assertEqual(arnold.AiArrayGetPnt(a, i), arnold.AtPoint(10)) self.assertEqual(arnold.AiArrayGetFlt(r, i), 0.5) for i in range(11, 20): self.assertEqual(arnold.AiArrayGetPnt(a, i), arnold.AtPoint(20)) self.assertEqual(arnold.AiArrayGetFlt(r, i), 1) a = arnold.AiNodeGetArray(n, "deform_time_samples") self.assertEqual(a.contents.nelements, 2) self.assertEqual(a.contents.nkeys, 1) self.assertEqual(arnold.AiArrayGetFlt(a, 0), -0.25) self.assertEqual(arnold.AiArrayGetFlt(a, 1), 0.25)
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(): node = IECoreArnold.NodeAlgo.convert([m1, m2], [-0.25, 0.25]) vList = arnold.AiNodeGetArray(node, "vlist") self.assertEqual(vList.contents.nelements, 4) self.assertEqual(vList.contents.nkeys, 2) nList = arnold.AiNodeGetArray(node, "nlist") self.assertEqual(nList.contents.nelements, 4) self.assertEqual(nList.contents.nkeys, 2) for i in range(0, 4): p = arnold.AiArrayGetPnt(vList, i) self.assertEqual(IECore.V3f(p.x, p.y, p.z), m1["P"].data[i]) n = arnold.AiArrayGetPnt(nList, i) self.assertEqual(IECore.V3f(n.x, n.y, n.z), m1["N"].data[i]) for i in range(4, 8): p = arnold.AiArrayGetPnt(vList, i) self.assertEqual(IECore.V3f(p.x, p.y, p.z), m2["P"].data[i - 4]) n = arnold.AiArrayGetPnt(nList, i) self.assertEqual(IECore.V3f(n.x, n.y, n.z), m2["N"].data[i - 4]) a = arnold.AiNodeGetArray(node, "deform_time_samples") self.assertEqual(a.contents.nelements, 2) self.assertEqual(a.contents.nkeys, 1) self.assertEqual(arnold.AiArrayGetFlt(a, 0), -0.25) self.assertEqual(arnold.AiArrayGetFlt(a, 1), 0.25)
def testVertexPrimitiveVariables(self): m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))) m["myPrimVar"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData([0, 1, 2, 3])) m["myV3fPrimVar"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([imath.V3f(v) for v in range(0, 4)])) with IECoreArnold.UniverseBlock(writable=True) as universe: n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh") a = arnold.AiNodeGetArray(n, "myPrimVar") v = arnold.AiNodeGetArray(n, "myV3fPrimVar") self.assertEqual(arnold.AiArrayGetNumElements(a.contents), 4) for i in range(0, 4): self.assertEqual(arnold.AiArrayGetFlt(a, i), i) self.assertEqual(arnold.AiArrayGetVec(v, i), i)
def testStringArray( self ) : with IECoreArnold.UniverseBlock( writable = True ) : n = arnold.AiNode( "polymesh" ) IECoreArnold.ParameterAlgo.setParameter( n, "trace_sets", IECore.StringVectorData( [ "a", "b" ] ) ) a = arnold.AiNodeGetArray( n, "trace_sets" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 2 ) self.assertEqual( arnold.AiArrayGetStr( a, 0 ), "a" ) self.assertEqual( arnold.AiArrayGetStr( a, 1 ), "b" )
def testVertexPrimitiveVariables(self): m = IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(-1), IECore.V2f(1))) m["myPrimVar"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData([0, 1, 2, 3])) m["myV3fPrimVar"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData([IECore.V3f(v) for v in range(0, 4)])) with IECoreArnold.UniverseBlock(): n = IECoreArnold.NodeAlgo.convert(m) a = arnold.AiNodeGetArray(n, "user:myPrimVar") v = arnold.AiNodeGetArray(n, "user:myV3fPrimVar") self.assertEqual(a.contents.nelements, 4) for i in range(0, 4): self.assertEqual(arnold.AiArrayGetFlt(a, i), i) self.assertEqual(arnold.AiArrayGetVec(v, i), i)
def testMotion(self): with IECoreArnold.UniverseBlock(writable=True): c = IECoreArnold.InstancingConverter() m1 = IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(-1), IECore.V2f(1))) m2 = IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(-2), IECore.V2f(2))) n1 = c.convert([m1, m2], -0.25, 0.25, "testMesh") self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n1)), "polymesh") self.assertEqual( arnold.AiArrayGetNumKeys( arnold.AiNodeGetArray(n1, "vlist").contents), 2) n2 = c.convert([m1, m2], -0.25, 0.25, "testInstance") self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n2)), "ginstance") self.assertEqual(arnold.AiNodeGetPtr(n2, "node"), ctypes.addressof(n1.contents)) n3 = c.convert([m2, m1], -0.25, 0.25, "testMesh") self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n1)), "polymesh") self.assertEqual( arnold.AiArrayGetNumKeys( arnold.AiNodeGetArray(n1, "vlist").contents), 2) n4 = c.convert([m1, m2], -0.5, 0.5, "testInstance") self.assertEqual( arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n1)), "polymesh") self.assertEqual( arnold.AiArrayGetNumKeys( arnold.AiNodeGetArray(n1, "vlist").contents), 2)
def testIntData( self ) : with IECoreArnold.UniverseBlock( writable = True ) : n = arnold.AiNode( "standard_surface" ) IECoreArnold.ParameterAlgo.setParameter( n, "customInt", IECore.IntData( 42 ) ) IECoreArnold.ParameterAlgo.setParameter( n, "customUInt", IECore.UIntData( 43 ) ) IECoreArnold.ParameterAlgo.setParameter( n, "customIntVectorData", IECore.IntVectorData( [ 5, 6, 7 ] ) ) IECoreArnold.ParameterAlgo.setParameter( n, "customUIntVectorData", IECore.UIntVectorData( [ 12, 2147483649 ] ) ) self.assertEqual( arnold.AiNodeGetInt( n, "customInt" ), 42 ) self.assertEqual( arnold.AiNodeGetUInt( n, "customUInt" ), 43 ) a = arnold.AiNodeGetArray( n, "customIntVectorData" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 3 ) self.assertEqual( arnold.AiArrayGetInt( a, 0 ), 5 ) self.assertEqual( arnold.AiArrayGetInt( a, 1 ), 6 ) self.assertEqual( arnold.AiArrayGetInt( a, 2 ), 7 ) a = arnold.AiNodeGetArray( n, "customUIntVectorData" ) self.assertEqual( arnold.AiArrayGetNumElements( a.contents ), 2 ) self.assertEqual( arnold.AiArrayGetUInt( a, 0 ), 12 ) self.assertEqual( arnold.AiArrayGetUInt( a, 1 ), 2147483649 )
def testUniformPrimitiveVariable( self ) : p = IECore.PointsPrimitive( IECore.V3fVectorData( 10 ) ) p["myPrimVar"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.IntVectorData( range( 0, 10 ) ) ) with IECoreArnold.UniverseBlock() : n = IECoreArnold.ToArnoldPointsConverter( p ).convert() a = arnold.AiNodeGetArray( n, "user:myPrimVar" ) self.assertEqual( a.contents.nelements, 10 ) for i in range( 0, 10 ) : self.assertEqual( arnold.AiArrayGetInt( a, i ), i )
def testConstantArrayPrimitiveVariable( self ) : p = IECore.PointsPrimitive( IECore.V3fVectorData( 10 ) ) p["myPrimVar"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.IntVectorData( range( 0, 10 ) ) ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( p ) a = arnold.AiNodeGetArray( n, "myPrimVar" ) self.assertEqual( a.contents.nelements, 10 ) for i in range( 0, 10 ) : self.assertEqual( arnold.AiArrayGetInt( a, i ), i )
def testCornersAndCreases(self): m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))) m.setInterpolation("catmullClark") m.setCorners(IECore.IntVectorData([3]), IECore.FloatVectorData([5])) m.setCreases(IECore.IntVectorData([3]), IECore.IntVectorData([0, 1, 2]), IECore.FloatVectorData([6])) with IECoreArnold.UniverseBlock(writable=True) as universe: n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh") idxArray = arnold.AiNodeGetArray(n, "crease_idxs") for i, v in enumerate([0, 1, 1, 2, 3, 3]): self.assertEqual(arnold.AiArrayGetUInt(idxArray, i), v) sharpnessArray = arnold.AiNodeGetArray(n, "crease_sharpness") for i, v in enumerate([6, 6, 5]): self.assertEqual(arnold.AiArrayGetFlt(sharpnessArray, i), v)
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 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(a.contents), 10) self.assertEqual(arnold.AiArrayGetNumKeys(a.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 testUVs(self): m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))) 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 testFaceVaryingPrimitiveVariables( self ) : m = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ), IECore.V2i( 2 ), ) self.assertEqual( m.variableSize( IECore.PrimitiveVariable.Interpolation.FaceVarying ), 16 ) m["myPrimVar"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.FaceVarying, IECore.FloatVectorData( range( 0, 16 ) ) ) with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( m ) a = arnold.AiNodeGetArray( n, "myPrimVar" ) ia = arnold.AiNodeGetArray( n, "myPrimVaridxs" ) self.assertEqual( a.contents.nelements, 16 ) self.assertEqual( ia.contents.nelements, 16 ) for i in range( 0, 16 ) : self.assertEqual( arnold.AiArrayGetFlt( a, i ), i ) self.assertEqual( arnold.AiArrayGetUInt( ia, i ), i )
def testAdditionalUVs(self): m = IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(-1), IECore.V2f(1))) m["myMap_s"] = m["s"] m["myMap_t"] = m["t"] s, t = m["s"].data, m["t"].data with IECoreArnold.UniverseBlock(): n = IECoreArnold.NodeAlgo.convert(m) uvs = arnold.AiNodeGetArray(n, "myMap") self.assertEqual(uvs.contents.nelements, 4) uvIndices = arnold.AiNodeGetArray(n, "myMapidxs") self.assertEqual(uvIndices.contents.nelements, 4) for i in range(0, 4): p = arnold.AiArrayGetPnt2(uvs, i) self.assertEqual(arnold.AiArrayGetPnt2(uvs, i), arnold.AtPoint2(s[i], 1 - t[i])) self.assertEqual(arnold.AiArrayGetInt(uvIndices, i), i)
def testIndexedUVs( self ) : m = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) ) m["uv"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.FaceVarying, m["uv"].data, IECore.IntVectorData( [ 0, 3, 1, 2 ] ) ) uvData = m["uv"].data uvIds = m["uv"].indices with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( m ) uvs = arnold.AiNodeGetArray( n, "uvlist" ) self.assertEqual( uvs.contents.nelements, 4 ) uvIndices = arnold.AiNodeGetArray( n, "uvidxs" ) self.assertEqual( uvIndices.contents.nelements, 4 ) for i in range( 0, 4 ) : aiUv = arnold.AiArrayGetPnt2( uvs, i ) aiUVId = arnold.AiArrayGetInt( uvIndices, i ) aiIndexedUV = arnold.AiArrayGetPnt2( uvs, aiUVId ) self.assertEqual( aiUVId, uvIds[i] ) self.assertEqual( aiUv, arnold.AtPoint2( uvData[i][0], uvData[i][1] ) ) self.assertEqual( aiIndexedUV, arnold.AtPoint2( uvData[uvIds[i]][0], uvData[uvIds[i]][1] ) )