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