def testUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["uv"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying,
m["uv"].expandedData())
uvData = m["uv"].data
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "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 testIndexedUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
uvData = m["uv"].data
uvIds = m["uv"].indices
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
aiUv = arnold.AiArrayGetVec2(uvs, i)
aiUVId = arnold.AiArrayGetInt(uvIndices, i)
aiIndexedUV = arnold.AiArrayGetVec2(uvs, aiUVId)
self.assertEqual(aiUVId, uvIds[i])
self.assertEqual(aiUv,
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(
aiIndexedUV,
arnold.AtVector2(uvData[uvIds[i]][0], uvData[uvIds[i]][1]))
def testAdditionalUVs(self):
m = IECoreScene.MeshPrimitive.createPlane(
imath.Box2f(imath.V2f(-1), imath.V2f(1)))
m["myMap"] = m["uv"]
uvData = m["myMap"].data
indicesData = m["myMap"].indices
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvs = arnold.AiNodeGetArray(n, "myMap")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "myMapidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
p = arnold.AiArrayGetVec2(uvs, i)
self.assertEqual(arnold.AiArrayGetVec2(uvs, i),
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(arnold.AiArrayGetInt(uvIndices, i),
indicesData[i])
def 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 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, "testMesh")
uvs = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvs.contents), 4)
uvIndices = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(arnold.AiArrayGetNumElements(uvIndices.contents),
4)
for i in range(0, 4):
aiUv = arnold.AiArrayGetVec2(uvs, i)
aiUVId = arnold.AiArrayGetInt(uvIndices, i)
aiIndexedUV = arnold.AiArrayGetVec2(uvs, aiUVId)
self.assertEqual(aiUVId, uvIds[i])
self.assertEqual(aiUv,
arnold.AtVector2(uvData[i][0], uvData[i][1]))
self.assertEqual(
aiIndexedUV,
arnold.AtVector2(uvData[uvIds[i]][0], uvData[uvIds[i]][1]))
def testExpandVertexIndexedUVs(self):
vertsPerFace = IECore.IntVectorData([4, 4])
vertexIds = IECore.IntVectorData([0, 1, 4, 3, 1, 2, 5, 4])
positions = IECore.V3fVectorData([
imath.V3f(0, 0, 0),
imath.V3f(1, 0, 0),
imath.V3f(2, 0, 0),
imath.V3f(0, 1, 0),
imath.V3f(1, 1, 0),
imath.V3f(2, 1, 0)
])
m = IECoreScene.MeshPrimitive(vertsPerFace, vertexIds, "linear",
positions)
m["uv"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V2fVectorData([
imath.V2f(0, 0),
imath.V2f(1, 0),
imath.V2f(0, 1),
imath.V2f(1, 1)
], IECore.GeometricData.Interpretation.UV),
IECore.IntVectorData([0, 1, 1, 2, 3, 3]))
self.assertTrue(m.arePrimitiveVariablesValid())
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(m, universe, "testMesh")
uvArray = arnold.AiNodeGetArray(n, "uvlist")
self.assertEqual(arnold.AiArrayGetNumElements(uvArray.contents), 4)
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 0),
arnold.AtVector2(0, 0))
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 1),
arnold.AtVector2(1, 0))
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 2),
arnold.AtVector2(0, 1))
self.assertEqual(arnold.AiArrayGetVec2(uvArray, 3),
arnold.AtVector2(1, 1))
uvIndicesArray = arnold.AiNodeGetArray(n, "uvidxs")
self.assertEqual(
arnold.AiArrayGetNumElements(uvIndicesArray.contents), 8)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 0), 0)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 1), 1)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 2), 3)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 3), 2)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 4), 1)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 5), 1)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 6), 3)
self.assertEqual(arnold.AiArrayGetInt(uvIndicesArray, 7), 3)
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 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, "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 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)
