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 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 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 testVectorIntData( self ) : with IECoreArnold.UniverseBlock( writable = True ) : n = arnold.AiNode( "standard_surface" ) IECoreArnold.ParameterAlgo.setParameter( n, "customV2i", IECore.V2iData( IECore.V2i( 3, 4 ) ) ) self.assertEqual( arnold.AiNodeGetVec2( n, "customV2i" ), arnold.AtVector2( 3, 4 ) ) IECoreArnold.ParameterAlgo.setParameter( n, "customV3i", IECore.V3iData( IECore.V3i( 3, 4, 5 ) ) ) self.assertEqual( arnold.AiNodeGetVec( n, "customV3i" ), arnold.AtVector( 3, 4, 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 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)
