def testFrameAndAASeed( self ) : options = GafferArnold.ArnoldOptions() render = GafferArnold.ArnoldRender() render["in"].setInput( options["out"] ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) for frame in ( 1, 2, 2.8, 3.2 ) : for seed in ( None, 3, 4 ) : with Gaffer.Context() as c : c.setFrame( frame ) options["options"]["aaSeed"]["enabled"].setValue( seed is not None ) options["options"]["aaSeed"]["value"].setValue( seed or 1 ) render["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) self.assertEqual( arnold.AiNodeGetInt( arnold.AiUniverseGetOptions(), "AA_seed" ), seed or round( frame ) )
def testCropWindow(self): r = GafferScene.Private.IECoreScenePreview.Renderer.create( "IECoreArnold::Renderer", GafferScene.Private.IECoreScenePreview. Renderer.RenderType.SceneDescription, self.temporaryDirectory() + "/test.ass") r.camera( "testCamera", IECore.Camera( parameters={ "resolution": IECore.V2i(2000, 1000), "cropWindow": IECore.Box2f(IECore.V2f(0), IECore.V2f(1, 0.75)), })) r.option("camera", IECore.StringData("testCamera")) r.render() del r with IECoreArnold.UniverseBlock(): arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass") options = arnold.AiUniverseGetOptions() self.assertEqual(arnold.AiNodeGetInt(options, "xres"), 2000) self.assertEqual(arnold.AiNodeGetInt(options, "yres"), 1000) self.assertEqual(arnold.AiNodeGetInt(options, "region_min_x"), 0) self.assertEqual(arnold.AiNodeGetInt(options, "region_min_y"), 0) self.assertEqual(arnold.AiNodeGetInt(options, "region_max_x"), 1999) self.assertEqual(arnold.AiNodeGetInt(options, "region_max_y"), 749)
def setUp(self): self.output_file_name = os.path.join(tempfile.gettempdir(), "result.exr") ai.AiBegin() ai.AiMsgSetConsoleFlags(ai.AI_LOG_NONE) ai.AiMsgSetConsoleFlags(ai.AI_LOG_WARNINGS | ai.AI_LOG_ERRORS) options = ai.AiUniverseGetOptions() ai.AiNodeSetBool(options, "skip_license_check", True) ai.AiNodeSetInt(options, "xres", 16) ai.AiNodeSetInt(options, "yres", 16) self.my_camera = ai.AiNode("persp_camera", "my_camera", None) self.my_filter = ai.AiNode("gaussian_filter", "my_filter", None) self.my_driver = ai.AiNode("driver_exr", "my_driver", None) self.my_cryptomatte = ai.AiNode("cryptomatte", "my_cryptomatte", None) ai.AiNodeSetStr(self.my_driver, "filename", self.output_file_name) ai.AiNodeSetPtr(options, "aov_shaders", self.my_cryptomatte) self.assertTrue( self.my_cryptomatte, ("Cryptomatte node could not be created, plugin may not be " "loaded in Python. (There may be binary compatibily issues " "with Python). "))
def testResolution(self): s = Gaffer.ScriptNode() s["camera"] = GafferScene.Camera() s["options"] = GafferScene.StandardOptions() s["options"]["in"].setInput(s["camera"]["out"]) s["options"]["options"]["renderResolution"]["enabled"].setValue(True) s["options"]["options"]["renderResolution"]["value"].setValue( imath.V2i(200, 100)) s["options"]["options"]["resolutionMultiplier"]["enabled"].setValue( True) s["options"]["options"]["resolutionMultiplier"]["value"].setValue(2) 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") # Default camera should have the right resolution. s["render"]["task"].execute() with IECoreArnold.UniverseBlock(writable=True): arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass") options = arnold.AiUniverseGetOptions() self.assertEqual(arnold.AiNodeGetInt(options, "xres"), 400) self.assertEqual(arnold.AiNodeGetInt(options, "yres"), 200) # As should a camera picked from the scene. s["options"]["options"]["renderCamera"]["enabled"].setValue(True) s["options"]["options"]["renderCamera"]["value"].setValue("/camera") s["render"]["task"].execute() with IECoreArnold.UniverseBlock(writable=True): arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass") options = arnold.AiUniverseGetOptions() self.assertEqual(arnold.AiNodeGetInt(options, "xres"), 400) self.assertEqual(arnold.AiNodeGetInt(options, "yres"), 200)
def createUniverseOptions(attributes): """ Method to define the render options This method is called to set the rendering parameters Args: attributes(dict): The dictionary with attribute name, (type,value) Returns: options(AiUniverseGetOptions): The variable with the render parameters set """ options = arnold.AiUniverseGetOptions() assignAttributes(options, attributes) return options
def _test_setup(self, outputs_init, correct_outputs): """ Tests setup of outputs occurs correctly with a full precision driver HALF aovs should be preserved, but no new AOVs should be set to HALF. """ options = ai.AiUniverseGetOptions() orig_num = len(outputs_init) ai.AiNodeSetArray(options, "outputs", self.list_to_array(outputs_init)) ai.AiRender() found_outputs = self.array_to_list( ai.AiNodeGetArray(options, "outputs")) # check original aovs self.assertEqual(correct_outputs[:orig_num], found_outputs[:orig_num]) # check addutional aovs self.assertEqual(correct_outputs[orig_num:], found_outputs[orig_num:])
def _worker(data, new_data, redraw_event, mmap_size, mmap_name, state): print("+++ _worker: started") import os import ctypes dir = os.path.dirname(__file__) if dir not in sys.path: sys.path.append(dir) import arnold nodes = {} lights = {} nptrs = [] # nodes linked by AiNodeSetPtr links = [] # nodes linked by AiNodeLink def _AiNodeSetArray(node, param, value): t, a = value _len = len(a) if t == arnold.AI_TYPE_VECTOR: _len //= 3 elif t == arnold.AI_TYPE_UINT: pass _a = arnold.AiArrayConvert(_len, 1, t, ctypes.c_void_p(a.ctypes.data)) arnold.AiNodeSetArray(node, param, _a) _AiNodeSet = { 'NodeSocketShader': lambda n, i, v: True, 'NodeSocketBool': lambda n, i, v: arnold.AiNodeSetBool(n, i, v), 'NodeSocketInt': lambda n, i, v: arnold.AiNodeSetInt(n, i, v), 'NodeSocketFloat': lambda n, i, v: arnold.AiNodeSetFlt(n, i, v), 'NodeSocketColor': lambda n, i, v: arnold.AiNodeSetRGBA(n, i, *v), 'NodeSocketVector': lambda n, i, v: arnold.AiNodeSetVec(n, i, *v), 'NodeSocketVectorXYZ': lambda n, i, v: arnold.AiNodeSetVector(n, i, *v), 'NodeSocketString': lambda n, i, v: arnold.AiNodeSetStr(n, i, v), 'ArnoldNodeSocketColor': lambda n, i, v: arnold.AiNodeSetRGB(n, i, *v), 'ArnoldNodeSocketByte': lambda n, i, v: arnold.AiNodeSetByte(n, i, v), 'ArnoldNodeSocketProperty': lambda n, i, v: True, 'BOOL': lambda n, p, v: arnold.AiNodeSetBool(n, p, v), 'BYTE': lambda n, p, v: arnold.AiNodeSetByte(n, p, v), 'INT': lambda n, p, v: arnold.AiNodeSetInt(n, p, v), 'FLOAT': lambda n, p, v: arnold.AiNodeSetFlt(n, p, v), 'VECTOR2': lambda n, p, v: arnold.AiNodeSetVec2(n, p, *v), 'RGB': lambda n, p, v: arnold.AiNodeSetRGB(n, p, *v), 'RGBA': lambda n, p, v: arnold.AiNodeSetRGBA(n, p, *v), 'VECTOR': lambda n, p, v: arnold.AiNodeSetVec(n, p, *v), 'STRING': lambda n, p, v: arnold.AiNodeSetStr(n, p, v), 'MATRIX': lambda n, p, v: arnold.AiNodeSetMatrix(n, p, arnold.AtMatrix(*v)), 'ARRAY': _AiNodeSetArray, 'LINK': lambda n, p, v: links.append((n, p, v)), 'NODE': lambda n, p, v: nptrs.append((n, p, v)), } arnold.AiBegin() try: # arnold.AiMsgSetConsoleFlags(arnold.AI_LOG_ALL) # arnold.AiMsgSetConsoleFlags(0x000E) # # from pprint import pprint as pp # pp(data) ## Nodes for node in data['nodes']: nt, np = node anode = arnold.AiNode(nt) for n, (t, v) in np.items(): _AiNodeSet[t](anode, n, v) nodes[id(node)] = anode for light in data['lights']: nt, np = light anode = arnold.AiNode(nt) for n, (t, v) in np.items(): _AiNodeSet[t](anode, n, v) lights[id(light)] = anode options = arnold.AiUniverseGetOptions() for n, (t, v) in data['options'].items(): _AiNodeSet[t](options, n, v) for n, p, v in nptrs: arnold.AiNodeSetPtr(n, p, nodes[id(v)]) for n, p, v in links: arnold.AiNodeLink(nodes[id(v)], p, n) ## Outputs filter = arnold.AiNode("gaussian_filter") arnold.AiNodeSetStr(filter, "name", "__filter") driver = arnold.AiNode("driver_display_callback") arnold.AiNodeSetStr(driver, "name", "__driver") #arnold.AiNodeSetBool(driver, "rgba_packing", False) outputs_aovs = (b"RGBA RGBA __filter __driver", ) outputs = arnold.AiArray(len(outputs_aovs), 1, arnold.AI_TYPE_STRING, *outputs_aovs) arnold.AiNodeSetArray(options, "outputs", outputs) sl = data['sl'] del nodes, nptrs, links, data if platform.system() == "Darwin" or "Linux": _rect = lambda w, h: numpy.frombuffer(mmap.mmap(-1, w * h * 4 * 4), dtype=numpy.float32).reshape( [h, w, 4]) rect = _rect(*mmap_size) if platform.system() == "Windows": _rect = lambda n, w, h: numpy.frombuffer( mmap.mmap(-1, w * h * 4 * 4, n), dtype=numpy.float32).reshape( [h, w, 4]) rect = _rect(mmap_name, *mmap_size) def _callback(x, y, width, height, buffer, data): #print("+++ _callback:", x, y, width, height, ctypes.cast(buffer, ctypes.c_void_p)) if buffer: try: if new_data.poll(): arnold.AiRenderInterrupt() else: #print("+++ _callback: tile", x, y, width, height) _buffer = ctypes.cast(buffer, ctypes.POINTER(ctypes.c_uint16)) a = numpy.ctypeslib.as_array(_buffer, shape=(height, width, 4)) rect[y:y + height, x:x + width] = a redraw_event.set() return finally: arnold.AiFree(buffer) elif not new_data.poll(): return arnold.AiRenderAbort() print("+++ _callback: abort") cb = arnold.AtDisplayCallBack(_callback) arnold.AiNodeSetPtr(driver, "callback", cb) class _Dict(dict): def update(self, u): for k, v in u.items(): if isinstance(v, dict): self[k] = _Dict.update(self.get(k, {}), v) else: self[k] = u[k] return self while state.value != ABORT: for _sl in range(*sl): arnold.AiNodeSetInt(options, "AA_samples", _sl) res = arnold.AiRender(arnold.AI_RENDER_MODE_CAMERA) if res == arnold.AI_SUCCESS: break if state.value == ABORT: #print("+++ _worker: abort") break data = _Dict() _data = new_data.recv() print(_data) while _data is not None: # from pprint import pprint as pp # print("+++ _worker: data") # pp(_data) data.update(_data) if not new_data.poll(): _nodes = data.get('nodes') if _nodes is not None: for name, params in _nodes.items(): node = arnold.AiNodeLookUpByName(name) for n, (t, v) in params.items(): _AiNodeSet[t](node, n, v) opts = data.get('options') if opts is not None: for n, (t, v) in opts.items(): _AiNodeSet[t](options, n, v) size = data.get('mmap_size') if size is not None: rect = _rect(mmap_name, *size) break _data = new_data.recv() finally: arnold.AiEnd() print("+++ _worker: finished")
def testRenderRegion( self ) : s = Gaffer.ScriptNode() s["camera"] = GafferScene.Camera() s["options"] = GafferScene.StandardOptions() s["options"]["in"].setInput( s["camera"]["out"] ) s["options"]["options"]["renderCamera"]["enabled"].setValue( True ) s["options"]["options"]["renderCamera"]["value"].setValue( "/camera" ) 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" ) # Default region s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 639 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 479 ) # Apply Crop Window s["options"]["options"]["renderCropWindow"]["enabled"].setValue( True ) s["options"]["options"]["renderCropWindow"]["value"].setValue( imath.Box2f( imath.V2f( 0.25, 0.5 ), imath.V2f( 0.75, 1.0 ) ) ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), 160 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 479 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), 240 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 479 ) # Test Empty Crop Window s["options"]["options"]["renderCropWindow"]["value"].setValue( imath.Box2f() ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) # Since Arnold doesn't support empty regions, we default to one pixel in the corner self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), 479 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 479 ) # Apply Overscan s["options"]["options"]["renderCropWindow"]["enabled"].setValue( False ) s["options"]["options"]["overscan"]["enabled"].setValue( True ) s["options"]["options"]["overscan"]["value"].setValue( True ) s["options"]["options"]["overscanTop"]["enabled"].setValue( True ) s["options"]["options"]["overscanTop"]["value"].setValue( 0.1 ) s["options"]["options"]["overscanBottom"]["enabled"].setValue( True ) s["options"]["options"]["overscanBottom"]["value"].setValue( 0.2 ) s["options"]["options"]["overscanLeft"]["enabled"].setValue( True ) s["options"]["options"]["overscanLeft"]["value"].setValue( 0.3 ) s["options"]["options"]["overscanRight"]["enabled"].setValue( True ) s["options"]["options"]["overscanRight"]["value"].setValue( 0.4 ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), -192 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 640 + 255 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), -48 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 480 + 95 )
def renderGeo(self): arnold.AiBegin() arnold.AiMsgSetLogFileName(self._logFile) arnold.AiMsgSetConsoleFlags(arnold.AI_LOG_ALL) # create a sphere geometric primitive sph = arnold.AiNode("sphere") arnold.AiNodeSetStr(sph, "name", "mysphere") arnold.AiNodeSetVec(sph, "center", 0.0, 4.0, 0.0) arnold.AiNodeSetFlt(sph, "radius", 5.0) # create a red standard shader shader1 = arnold.AiNode("standard") arnold.AiNodeSetStr(shader1, "name", "myshader1") arnold.AiNodeSetRGB(shader1, "Kd_color", self._color[0], self._color[1], self._color[2]) arnold.AiNodeSetFlt(shader1, "Ks", 0.05) # assign the shaders to the geometric objects arnold.AiNodeSetPtr(sph, "shader", shader1) # create a perspective camera camera = arnold.AiNode("persp_camera") arnold.AiNodeSetStr(camera, "name", "mycamera") # position the camera (alternatively you can set 'matrix') arnold.AiNodeSetVec(camera, "position", 0.0, 10.0, 35.0) arnold.AiNodeSetVec(camera, "look_at", 0.0, 3.0, 0.0) arnold.AiNodeSetFlt(camera, "fov", 45.0) # create a point light source light = arnold.AiNode("point_light") arnold.AiNodeSetStr(light, "name", "pointLight_A") # // position the light (alternatively use 'matrix') arnold.AiNodeSetVec(light, "position", 0.0, 30.0, 0.0) arnold.AiNodeSetFlt(light, "intensity", 10.0) # alternatively, use 'exposure' arnold.AiNodeSetFlt(light, "radius", 4.0) # for soft shadows # create a point light source light = arnold.AiNode("point_light") arnold.AiNodeSetStr(light, "name", "pointLight_B") # // position the light (alternatively use 'matrix') arnold.AiNodeSetVec(light, "position", 0.0, -30.0, 0.0) arnold.AiNodeSetFlt(light, "intensity", 10.0) # alternatively, use 'exposure' arnold.AiNodeSetFlt(light, "radius", 4.0) # for soft shadows # create a point light source light = arnold.AiNode("point_light") arnold.AiNodeSetStr(light, "name", "pointLight_C") # // position the light (alternatively use 'matrix') arnold.AiNodeSetVec(light, "position", 0.0, 4.0, 20.0) arnold.AiNodeSetFlt(light, "intensity", 5.0) # alternatively, use 'exposure' arnold.AiNodeSetFlt(light, "radius", 15.0) # for soft shadows # // get the global options node and set some options options = arnold.AiUniverseGetOptions() arnold.AiNodeSetInt(options, "AA_samples", 8) arnold.AiNodeSetInt(options, "xres", 480) arnold.AiNodeSetInt(options, "yres", 360) arnold.AiNodeSetInt(options, "GI_diffuse_depth", 4) # // set the active camera (optional, since there is only one camera) arnold.AiNodeSetPtr(options, "camera", camera) # create an output driver node driver = arnold.AiNode("driver_jpeg") arnold.AiNodeSetStr(driver, "name", "mydriver") arnold.AiNodeSetStr(driver, "filename", self._sceneName) arnold.AiNodeSetFlt(driver, "gamma", 2.2) # create a gaussian filter node filter = arnold.AiNode("gaussian_filter") arnold.AiNodeSetStr(filter, "name", "myfilter") # assign the driver and filter to the main (beauty) AOV, # which is called "RGBA" and is of type RGBA outputs_array = arnold.AiArrayAllocate(1, 1, arnold.AI_TYPE_STRING) arnold.AiArraySetStr(outputs_array, 0, "RGBA RGBA myfilter mydriver") arnold.AiNodeSetArray(options, "outputs", outputs_array) # finally, render the image! arnold.AiRender(arnold.AI_RENDER_MODE_CAMERA) # // Arnold session shutdown arnold.AiEnd()
def __init__(self): super().__init__() self.data = arnold.AiUniverseGetOptions()
def renderGeo(self): """ This method calls the arnold functions to setup and scene and render the image """ arnold.AiBegin() arnold.AiMsgSetLogFileName(self.log) arnold.AiMsgSetConsoleFlags(arnold.AI_LOG_ALL) attributes = { "Kd_color": ("rgb", (self._color[0], self._color[1], self._color[2])), "Ks": ("float", 0.05), "Ko": ("float", .5), } shader = createSimpleShader("standard", "myshader1", attributes) attributes = { "center": ("vector", (0.0, 4.0, 0.0)), "radius": ("float", 5.0), "shader": ("pointer", shader) } sph = createGeometry("sphere", "mysphere", attributes) # attributes["center"] = ("vector", (1.0, 2.0, 3.0)) # sph1 = createGeometry("sphere", "mysphere", attributes) # assignAttributes(sph, {"radius": ("float", 0.9)}) # arnold.AiNodeSetRGB(shader1, "Kd_color", self._color[0], self._color[1], self._color[2]) # arnold.AiNodeSetFlt(shader1, "Ks", 0.05) # # assign the shaders to the geometric objects # arnold.AiNodeSetPtr(sph, "shader", shader1) # create a perspective camera camera = arnold.AiNode("persp_camera") arnold.AiNodeSetStr(camera, "name", "mycamera") arnold.AiNodeSetVec(camera, "position", 0.0, 10.0, 35.0) arnold.AiNodeSetVec(camera, "look_at", 0.0, 3.0, 0.0) arnold.AiNodeSetFlt(camera, "fov", 45.0) # create a point light source light = arnold.AiNode("point_light") arnold.AiNodeSetStr(light, "name", "pointLight_A") arnold.AiNodeSetVec(light, "position", 0.0, 30.0, 0.0) arnold.AiNodeSetFlt(light, "intensity", 10.0) arnold.AiNodeSetFlt(light, "radius", 4.0) # create a point light source light = arnold.AiNode("point_light") arnold.AiNodeSetStr(light, "name", "pointLight_B") arnold.AiNodeSetVec(light, "position", 0.0, -30.0, 0.0) arnold.AiNodeSetFlt(light, "intensity", 10.0) arnold.AiNodeSetFlt(light, "radius", 4.0) # create a point light source light = arnold.AiNode("point_light") arnold.AiNodeSetStr(light, "name", "pointLight_C") arnold.AiNodeSetVec(light, "position", 0.0, 4.0, 20.0) arnold.AiNodeSetFlt(light, "intensity", 5.0) arnold.AiNodeSetFlt(light, "radius", 15.0) # get the global options node and set some options options = arnold.AiUniverseGetOptions() arnold.AiNodeSetInt(options, "AA_samples", 8) arnold.AiNodeSetInt(options, "xres", 480) arnold.AiNodeSetInt(options, "yres", 360) arnold.AiNodeSetInt(options, "GI_diffuse_depth", 4) arnold.AiNodeSetPtr(options, "camera", camera) # create an output driver node driver = arnold.AiNode("driver_jpeg") arnold.AiNodeSetStr(driver, "name", "mydriver") # arnold.AiNodeSetStr(driver, "filepath", os.path.dirname(self.image)) arnold.AiNodeSetStr(driver, "filename", os.path.basename(self.image)) arnold.AiNodeSetFlt(driver, "gamma", 2.2) # create a gaussian filter node filter = arnold.AiNode("gaussian_filter") arnold.AiNodeSetStr(filter, "name", "myfilter") # assign the driver and filter to the main (beauty) AOV, # which is called "RGBA" and is of type RGBA outputs_array = arnold.AiArrayAllocate(1, 1, arnold.AI_TYPE_STRING) arnold.AiArraySetStr(outputs_array, 0, "RGBA RGBA myfilter mydriver") arnold.AiNodeSetArray(options, "outputs", outputs_array) # finally, render the image! arnold.AiRender(arnold.AI_RENDER_MODE_CAMERA) # // Arnold session shutdown arnold.AiEnd()