def testPartialConnectionSerialisation(self): s = IECore.Splineff(IECore.CubicBasisf.catmullRom(), ( (0, 0), (0, 0), (0.2, 0.3), (0.4, 0.9), (1, 1), (1, 1), )) script = Gaffer.ScriptNode() script["n"] = Gaffer.Node() script["n"]["user"]["s"] = Gaffer.SplineffPlug( defaultValue=s, flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) script["n"]["user"]["x"] = Gaffer.FloatPlug( flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) script["n"]["user"]["y"] = Gaffer.FloatPlug( flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) script["n"]["user"]["s"].pointXPlug(0).setInput( script["n"]["user"]["x"]) script["n"]["user"]["s"].pointYPlug(2).setInput( script["n"]["user"]["y"]) def assertConnection(script): self.assertTrue(script["n"]["user"]["s"].getInput() is None) self.assertTrue( script["n"]["user"]["s"]["basis"].getInput() is None) for i in range(0, 4): if i == 0: self.assertTrue(script["n"]["user"]["s"].pointXPlug( i).getInput().isSame(script["n"]["user"]["x"])) else: self.assertTrue(script["n"]["user"]["s"].pointXPlug( i).getInput() is None) if i == 2: self.assertTrue(script["n"]["user"]["s"].pointYPlug( i).getInput().isSame(script["n"]["user"]["y"])) else: self.assertTrue(script["n"]["user"]["s"].pointYPlug( i).getInput() is None) assertConnection(script) script2 = Gaffer.ScriptNode() script2.execute(script.serialise()) assertConnection(script2)
def testFloatPlugs( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["i"] = Gaffer.FloatPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n"]["user"]["o"] = Gaffer.FloatPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["e"] = Gaffer.Expression() s["e"].setExpression( "parent.n.user.o = parent.n.user.i + 1;", "OSL" ) s["n"]["user"]["i"].setValue( 1 ) self.assertEqual( s["n"]["user"]["o"].getValue(), 2 )
def __init__( self, name = "_Camera" ) : Gaffer.Node.__init__( self, name ) self["in"] = GafferScene.ScenePlug() self["addCamera"] = Gaffer.BoolPlug( defaultValue = False ) self["lookAt"] = Gaffer.StringPlug( defaultValue = "/" ) self["depth"] = Gaffer.FloatPlug( defaultValue = 20, minValue = 0 ) self["angle"] = Gaffer.FloatPlug() self["elevation"] = Gaffer.FloatPlug( defaultValue = 10, minValue = -90, maxValue = 90 ) self["camera"] = GafferScene.Camera() self["camera"]["name"].setValue( "previewCamera" ) self["parent"] = GafferScene.Parent() self["parent"]["in"].setInput( self["in"] ) self["parent"]["parent"].setValue( "/" ) self["parent"]["child"].setInput( self["camera"]["out"] ) self["cameraFilter"] = GafferScene.PathFilter() self["cameraFilter"]["paths"].setValue( IECore.StringVectorData( [ "/previewCamera" ] ) ) self["parentConstraint"] = GafferScene.ParentConstraint() self["parentConstraint"]["in"].setInput( self["parent"]["out"] ) self["parentConstraint"]["target"].setInput( self["lookAt"] ) self["parentConstraint"]["targetMode"].setValue( self["parentConstraint"].TargetMode.BoundCenter ) self["parentConstraint"]["filter"].setInput( self["cameraFilter"]["out"] ) self["cameraRotate"] = GafferScene.Transform() self["cameraRotate"]["in"].setInput( self["parentConstraint"]["out"] ) self["cameraRotate"]["transform"]["rotate"]["y"].setInput( self["angle"] ) self["cameraRotate"]["filter"].setInput( self["cameraFilter"]["out"] ) self["elevationExpression"] = Gaffer.Expression() self["elevationExpression"].setExpression( 'parent["cameraRotate"]["transform"]["rotate"]["x"] = -parent["elevation"]' ) self["cameraTranslate"] = GafferScene.Transform() self["cameraTranslate"]["in"].setInput( self["cameraRotate"]["out"] ) self["cameraTranslate"]["transform"]["translate"]["z"].setInput( self["depth"] ) self["cameraTranslate"]["filter"].setInput( self["cameraFilter"]["out"] ) self["options"] = GafferScene.StandardOptions() self["options"]["options"]["renderCamera"]["enabled"].setValue( True ) self["options"]["options"]["renderCamera"]["value"].setValue( "/previewCamera" ) self["options"]["in"].setInput( self["cameraTranslate"]["out"] ) self["switch"] = GafferScene.SceneSwitch() self["switch"]["in"].setInput( self["in"] ) self["switch"]["in1"].setInput( self["options"]["out"] ) self["switch"]["index"].setInput( self["addCamera"] ) self["out"] = GafferScene.ScenePlug( direction = Gaffer.Plug.Direction.Out ) self["out"].setInput( self["switch"]["out"] )
def testChildRemovalPropagatesToOutputs(self): s = Gaffer.ScriptNode() s["n1"] = Gaffer.Node() s["n2"] = Gaffer.Node() s["n1"]["c"] = Gaffer.Plug() s["n2"]["c"] = Gaffer.Plug() s["n1"]["c"]["f"] = Gaffer.FloatPlug() s["n2"]["c"]["f"] = Gaffer.FloatPlug() s["n1"]["c"]["i"] = Gaffer.FloatPlug() s["n2"]["c"]["i"] = Gaffer.FloatPlug() s["n2"]["c"].setInput(s["n1"]["c"]) def assertPreconditions(): self.assertEqual(s["n1"]["c"].keys(), ["f", "i"]) self.assertEqual(s["n2"]["c"].keys(), ["f", "i"]) self.assertTrue(s["n2"]["c"].getInput().isSame(s["n1"]["c"])) self.assertTrue(s["n2"]["c"]["i"].getInput().isSame( s["n1"]["c"]["i"])) self.assertTrue(s["n2"]["c"]["f"].getInput().isSame( s["n1"]["c"]["f"])) def assertPostconditions(): self.assertEqual(s["n1"]["c"].keys(), []) self.assertEqual(s["n2"]["c"].keys(), []) self.assertTrue(s["n2"]["c"].getInput().isSame(s["n1"]["c"])) assertPreconditions() with Gaffer.UndoContext(s): del s["n1"]["c"]["i"] del s["n1"]["c"]["f"] assertPostconditions() s.undo() assertPreconditions() s.redo() assertPostconditions()
def testHaveMinMaxValues(self): f = Gaffer.FloatPlug() self.assertEqual(f.hasMinValue(), False) self.assertEqual(f.hasMaxValue(), False) f = Gaffer.FloatPlug(minValue=1) self.assertEqual(f.hasMinValue(), True) self.assertEqual(f.hasMaxValue(), False) f = Gaffer.FloatPlug(maxValue=1) self.assertEqual(f.hasMinValue(), False) self.assertEqual(f.hasMaxValue(), True)
def testIntermediateConversions(self): f1 = Gaffer.FloatPlug() i = Gaffer.IntPlug() f2 = Gaffer.FloatPlug() i.setInput(f1) f2.setInput(i) f1.setValue(10.2) self.assertEqual(f2.getValue(), 10) f1.setValue(100.8) self.assertEqual(f2.getValue(), 100)
def __createSpreadsheet(numRows=10): s = Gaffer.Spreadsheet() rowsPlug = s["rows"] # N = row number, starting at 1 # Rows named 'rowN' # Column 0 - string - 'sN' # Column 1 - int - N # Column 2 - int - 10N - even rows disabled # Column 3 - float - 100N # Column 4 - int - 1000N # Column 5 - compound plug # Column 6 - Non-adopted NameValuePlug # Column 7 - Adopted NameValuePlug compoundPlug = Gaffer.ValuePlug() compoundPlug["a"] = Gaffer.FloatPlug() compoundPlug["b"] = Gaffer.StringPlug() nameValuePlug = Gaffer.NameValuePlug("nvp", IECore.FloatData(0), True) for i, columnPlug in enumerate(( Gaffer.StringPlug(), # 0 Gaffer.IntPlug(), # 1 Gaffer.IntPlug(), # 2 Gaffer.FloatPlug(), # 3 Gaffer.IntPlug(), # 4 compoundPlug, # 5 nameValuePlug # 6 )): rowsPlug.addColumn(columnPlug, "column%d" % i, adoptEnabledPlug=False) rowsPlug.addColumn(nameValuePlug, "column7", adoptEnabledPlug=True) for i in range(1, numRows + 1): rowsPlug.addRow()["name"].setValue("row%d" % i) rowsPlug[i]["cells"][0]["value"].setValue("s%d" % (i)) rowsPlug[i]["cells"][2]["enabled"].setValue(i % 2) for c in range(1, 5): rowsPlug[i]["cells"][c]["value"].setValue(i * pow(10, c - 1)) rowsPlug[i]["cells"][5]["value"]["a"].setValue(i * 0.1) rowsPlug[i]["cells"][5]["value"]["b"].setValue("string %f" % (i * 0.1)) rowsPlug[i]["cells"][6]["value"]["value"].setValue(i * 0.01) return s
def testSerialisationRoundTripsExactly(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) context = Gaffer.Context() for frame in range(0, 10000): context.setFrame(frame) curve.addKey( Gaffer.Animation.Key(context.getTime(), context.getTime(), Gaffer.Animation.Type.Linear)) s2 = Gaffer.ScriptNode() s2.execute(s.serialise()) curve = Gaffer.Animation.acquire(s2["n"]["user"]["f"]) for frame in range(0, 10000): context.setFrame(frame) self.assertEqual( curve.getKey(context.getTime()), Gaffer.Animation.Key(context.getTime(), context.getTime(), Gaffer.Animation.Type.Linear))
def testNextAndPreviousKeys(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) key1 = Gaffer.Animation.Key(0, 0) key2 = Gaffer.Animation.Key(1, 1) key3 = Gaffer.Animation.Key(2, 2) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) curve.addKey(key1) curve.addKey(key2) curve.addKey(key3) self.assertEqual(curve.nextKey(-1), key1) self.assertEqual(curve.nextKey(0), key2) self.assertEqual(curve.nextKey(0.5), key2) self.assertEqual(curve.nextKey(1), key3) self.assertEqual(curve.nextKey(1.5), key3) self.assertFalse(curve.nextKey(2)) self.assertFalse(curve.previousKey(-1)) self.assertFalse(curve.previousKey(0)) self.assertEqual(curve.previousKey(0.5), key1) self.assertEqual(curve.previousKey(1), key1) self.assertEqual(curve.previousKey(1.5), key2) self.assertEqual(curve.previousKey(2), key2) self.assertEqual(curve.previousKey(2.5), key3)
def testIdenticalExpressionWithDifferentPlugTypes(self): # IntPlug -> FloatPlug s1 = Gaffer.ScriptNode() s1["n"] = Gaffer.Node() s1["n"]["user"]["a"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s1["n"]["user"]["b"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s1["e"] = Gaffer.Expression() s1["e"].setExpression( 'parent["n"]["user"]["b"] = parent["n"]["user"]["a"]') s1["n"]["user"]["a"].setValue(1001) self.assertEqual(s1["n"]["user"]["b"].getValue(), 1001) # IntPlug -> IntPlug s2 = Gaffer.ScriptNode() s2["n"] = Gaffer.Node() s2["n"]["user"]["a"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s2["n"]["user"]["b"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s2["e"] = Gaffer.Expression() s2["e"].setExpression( 'parent["n"]["user"]["b"] = parent["n"]["user"]["a"]') s2["n"]["user"]["a"].setValue(1001) self.assertEqual(s2["n"]["user"]["b"].getValue(), 1001)
def testCollaboratePerf(self): # Test an expensive OSLImage, with many output tiles depending on the same input tiles, # which should give TaskCollaborate a chance to show some benefit constant = GafferImage.Constant() constant["format"].setValue(GafferImage.Format(128, 128)) deleteChannels = GafferImage.DeleteChannels("DeleteChannels") deleteChannels["in"].setInput(constant["out"]) deleteChannels["mode"].setValue(GafferImage.DeleteChannels.Mode.Keep) deleteChannels["channels"].setValue('R') mandelbrotCode = self.mandelbrotNode() mandelbrotCode["parameters"]["iterations"].setValue(500000) oslImage = GafferOSL.OSLImage() oslImage["in"].setInput(deleteChannels["out"]) oslImage["channels"].addChild( Gaffer.NameValuePlug("R", Gaffer.FloatPlug("value"), True, "channel")) oslImage["channels"]["channel"]["value"].setInput( mandelbrotCode["out"]["outFloat"]) resize = GafferImage.Resize() resize["in"].setInput(oslImage["out"]) resize["format"].setValue( GafferImage.Format(imath.Box2i(imath.V2i(0), imath.V2i(2048)), 1)) # We use a resize because it pulls the input tiles repeatedly, we don't want to spend time on resizing # pixels, so use a fast filter resize["filter"].setValue('box') with GafferTest.TestRunner.PerformanceScope(): GafferImage.ImageAlgo.image(resize["out"])
def __addPlug(self, name, defaultData): alphaValue = None if isinstance(defaultData, IECore.Color4fData): alphaValue = Gaffer.FloatPlug("value", Gaffer.Plug.Direction.In, defaultData.value.a) defaultData = IECore.Color3fData( imath.Color3f(defaultData.value.r, defaultData.value.g, defaultData.value.b)) if defaultData == None: plugName = "closure" name = "" valuePlug = GafferOSL.ClosurePlug("value") else: plugName = "channel" valuePlug = Gaffer.PlugAlgo.createPlugFromData( "value", Gaffer.Plug.Direction.In, Gaffer.Plug.Flags.Default, defaultData) with Gaffer.UndoScope(self.getPlug().ancestor(Gaffer.ScriptNode)): self.getPlug().addChild( Gaffer.NameValuePlug( name, valuePlug, True, plugName, Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)) if alphaValue: self.getPlug().addChild( Gaffer.NameValuePlug( name + ".A" if name else "A", alphaValue, True, plugName, Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic))
def testReloadPreservesConnectionsWhenMinMaxOrDefaultChanges( self ) : shader1 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version1.sl", shaderName = "unversioned" ) n = GafferRenderMan.RenderManShader() n.loadShader( shader1 ) self.assertFalse( n["parameters"]["float1"].hasMinValue() ) self.assertFalse( n["parameters"]["float1"].hasMaxValue() ) self.assertEqual( n["parameters"]["string1"].defaultValue(), "" ) nn = Gaffer.Node() nn["outFloat"] = Gaffer.FloatPlug( direction = Gaffer.Plug.Direction.Out ) nn["outString"] = Gaffer.StringPlug( direction = Gaffer.Plug.Direction.Out ) n["parameters"]["float1"].setInput( nn["outFloat"] ) n["parameters"]["string1"].setInput( nn["outString"] ) shader2 = self.compileShader( os.path.dirname( __file__ ) + "/shaders/version2.sl", shaderName = "unversioned" ) GafferRenderMan.RenderManShader.shaderLoader().clear() n.loadShader( shader1, keepExistingValues=True ) self.assertTrue( n["parameters"]["float1"].hasMinValue() ) self.assertTrue( n["parameters"]["float1"].hasMaxValue() ) self.assertEqual( n["parameters"]["float1"].minValue(), -1 ) self.assertEqual( n["parameters"]["float1"].maxValue(), 2 ) self.assertEqual( n["parameters"]["string1"].defaultValue(), "newDefaultValue" ) self.assertTrue( n["parameters"]["float1"].getInput().isSame( nn["outFloat"] ) ) self.assertTrue( n["parameters"]["string1"].getInput().isSame( nn["outString"] ) )
def testExpectedResult(self): ramp = GafferImage.Ramp() ramp["format"].setValue(GafferImage.Format(128, 128)) ramp["transform"]["rotate"].setValue(45) ramp["transform"]["scale"]["x"].setValue(.5) ramp["startPosition"].setValue(imath.V2f(0, 64)) ramp["endPosition"].setValue(imath.V2f(128, 64)) ramp["ramp"].addChild(Gaffer.ValuePlug("p2")) ramp["ramp"]["p2"].addChild( Gaffer.FloatPlug("x", defaultValue=0.5308765172958374)) ramp["ramp"]["p2"].addChild( Gaffer.Color4fPlug("y", defaultValue=imath.Color4f( 0.530900002, 0, 0, 0.50999999))) reader = GafferImage.ImageReader() reader["fileName"].setValue( os.path.dirname(__file__) + "/images/GafferRamp.exr") self.assertImagesEqual(ramp["out"], reader["out"], ignoreMetadata=True, maxDifference=0.001)
def testClosestKey(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) key0 = Gaffer.Animation.Key(0, 0) key1 = Gaffer.Animation.Key(1, 1) curve.addKey(key0) curve.addKey(key1) self.assertEqual(curve.closestKey(-1), key0) self.assertEqual(curve.closestKey(-0.1), key0) self.assertEqual(curve.closestKey(0), key0) self.assertEqual(curve.closestKey(0.1), key0) self.assertEqual(curve.closestKey(0.49), key0) self.assertEqual(curve.closestKey(0.51), key1) self.assertEqual(curve.closestKey(0.75), key1) self.assertEqual(curve.closestKey(1), key1) self.assertEqual(curve.closestKey(1.1), key1) self.assertEqual(curve.closestKey(-1, 1), key0) self.assertEqual(curve.closestKey(-1, 0.9), None) self.assertEqual(curve.closestKey(0.75, 1), key1) self.assertEqual(curve.closestKey(0.75, 0.2), None)
def testPlugTypes(self): box = Gaffer.Box("PlugTypes") box["int"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) box["float"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) box["string"] = Gaffer.StringPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) box["v2i"] = Gaffer.V2iPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) box["v3i"] = Gaffer.V3iPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) box["color4f"] = Gaffer.Color4fPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) box["spline"] = Gaffer.SplinefColor3fPlug( flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) Gaffer.ExtensionAlgo.exportExtension("PlugTypesExtension", [box], self.temporaryDirectory()) sys.path.append(os.path.join(self.temporaryDirectory(), "python")) import PlugTypesExtension node = PlugTypesExtension.PlugTypes() for plug in Gaffer.Plug.Range(node): self.assertIsInstance(plug, type(box[plug.getName()])) if hasattr(plug, "getValue"): self.assertEqual(plug.getValue(), box[plug.getName()].getValue()) for plug in Gaffer.Plug.RecursiveRange(node): self.assertFalse(plug.getFlags(Gaffer.Plug.Flags.Dynamic))
def testStep(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) curve.addKey(Gaffer.Animation.Key(0, 0)) curve.addKey(Gaffer.Animation.Key(1, 1, Gaffer.Animation.Type.Linear)) curve.addKey(Gaffer.Animation.Key(2, 2, Gaffer.Animation.Type.Step)) with Gaffer.Context() as c: # Linear interpolation from 0 to 1. for i in range(0, 10): c.setTime(i / 9.0) self.assertAlmostEqual(s["n"]["user"]["f"].getValue(), c.getTime()) # Step interpolation from 1 to 2 for i in range(0, 10): c.setTime(1 + i / 10.0) self.assertEqual(s["n"]["user"]["f"].getValue(), 1) c.setTime(2) self.assertEqual(s["n"]["user"]["f"].getValue(), 2)
def testDefaultExpressionForSupportedPlugs( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"].addChild( Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.FloatPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.BoolPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V2fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V3iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Color4fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box2fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box3iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.IntVectorDataPlug( defaultValue = IECore.IntVectorData( [ 0, 1 ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.FloatVectorDataPlug( defaultValue = IECore.FloatVectorData( [ 0, 1 ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.StringVectorDataPlug( defaultValue = IECore.StringVectorData( [ "a", "b" ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V3fVectorDataPlug( defaultValue = IECore.V3fVectorData( [ IECore.V3f( 1 ) ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Color3fVectorDataPlug( defaultValue = IECore.Color3fVectorData( [ IECore.Color3f( 1 ) ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.M44fVectorDataPlug( defaultValue = IECore.M44fVectorData( [ IECore.M44f() ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V2iVectorDataPlug( defaultValue = IECore.V2iVectorData( [ IECore.V2i() ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["e"] = Gaffer.Expression() for plug in s["n"]["user"] : value = plug.getValue() s["e"].setExpression( s["e"].defaultExpression( plug, "python" ) ) self.assertTrue( plug.getInput().node().isSame( s["e"] ) ) self.assertEqual( plug.getValue(), value )
def testSerialisation(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) curve.addKey(Gaffer.Animation.Key(0, 0, Gaffer.Animation.Type.Linear)) curve.addKey(Gaffer.Animation.Key(1, 1, Gaffer.Animation.Type.Linear)) def assertAnimation(script): curve = Gaffer.Animation.acquire(script["n"]["user"]["f"]) self.assertEqual( curve.getKey(0), Gaffer.Animation.Key(0, 0, Gaffer.Animation.Type.Linear)) self.assertEqual( curve.getKey(1), Gaffer.Animation.Key(1, 1, Gaffer.Animation.Type.Linear)) with Gaffer.Context() as c: for i in range(0, 10): c.setTime(i / 9.0) self.assertAlmostEqual(script["n"]["user"]["f"].getValue(), c.getTime()) assertAnimation(s) s2 = Gaffer.ScriptNode() s2.execute(s.serialise()) assertAnimation(s2)
def mandelbrotNode(self): mandelbrotCode = GafferOSL.OSLCode() mandelbrotCode["parameters"].addChild( Gaffer.IntPlug( "iterations", defaultValue=0, flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic, )) mandelbrotCode["out"].addChild( Gaffer.FloatPlug("outFloat", direction=Gaffer.Plug.Direction.Out)) mandelbrotCode["code"].setValue( inspect.cleandoc(""" // Basic mandelbrot adapted from surface shader here: // https://github.com/AcademySoftwareFoundation/OpenShadingLanguage/blob/master/src/shaders/mandelbrot.osl point center = point (0,0,0); float scale = 2; point cent = center; point c = scale * point(2*(u-0.5), 2*((1-v)-0.5), 0) + cent; point z = c; int i; for (i = 1; i < iterations && dot(z,z) < 4.0; ++i) { float x = z[0], y = z[1]; z = point (x*x - y*y, 2*x*y, 0) + c; } if (i < iterations) { float f = pow(float(i)/iterations, 1/log10(float(iterations))); outFloat = f; } else { outFloat = 0; } """)) return mandelbrotCode
def testUndoAddKey(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) self.assertFalse(curve.getKey(0)) key1 = Gaffer.Animation.Key(1, 0) key2 = Gaffer.Animation.Key(1, 1) with Gaffer.UndoScope(s): curve.addKey(key1) self.assertEqual(curve.getKey(1), key1) with Gaffer.UndoScope(s): curve.addKey(key2) self.assertEqual(curve.getKey(1), key2) s.undo() self.assertEqual(curve.getKey(1), key1) s.undo() self.assertFalse(curve.getKey(1)) s.redo() self.assertEqual(curve.getKey(1), key1) s.redo() self.assertEqual(curve.getKey(1), key2)
def testExpressionChangedSignal(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["p"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) expressions = [] def f(node): expressions.append(node.getExpression()) s["e"] = Gaffer.Expression() self.assertEqual(s["e"].getExpression(), ("", "")) c = s["e"].expressionChangedSignal().connect(f) with Gaffer.UndoContext(s): s["e"].setExpression('parent["n"]["user"]["p"] = 10') self.assertEqual(len(expressions), 1) self.assertEqual(expressions[0], ('parent["n"]["user"]["p"] = 10', "python")) s.undo() self.assertEqual(len(expressions), 2) self.assertEqual(expressions[1], ("", "")) s.redo() self.assertEqual(len(expressions), 3) self.assertEqual(expressions[2], expressions[0])
def testUndoRemoveKey(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) curve = Gaffer.Animation.acquire(s["n"]["user"]["f"]) key = Gaffer.Animation.Key(0, 0) curve.addKey(key) self.assertTrue(curve.getKey(key.getTime()).isSame(key)) with Gaffer.UndoScope(s): curve.removeKey(key) self.assertFalse(curve.hasKey(key.getTime())) self.assertEqual(key.parent(), None) s.undo() self.assertEqual(curve.getKey(key.getTime()), key) self.assertTrue(key.parent().isSame(curve)) s.redo() self.assertFalse(curve.hasKey(key.getTime())) self.assertEqual(key.parent(), None)
def testDefaultExpression(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["i"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["c"] = Gaffer.Color3fPlug( flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["v"] = Gaffer.V3fPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["s"] = Gaffer.StringPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["f"].setValue(10) s["n"]["user"]["i"].setValue(10) s["n"]["user"]["c"].setValue(IECore.Color3f(1, 2, 3)) s["n"]["user"]["v"].setValue(IECore.V3f(1, 2, 3)) s["n"]["user"]["s"].setValue("s") defaultExpressions = [ Gaffer.Expression.defaultExpression(p, "OSL") for p in s["n"]["user"].children() ] expectedValues = [p.getValue() for p in s["n"]["user"].children()] for p in s["n"]["user"].children(): p.setToDefault() s["e"] = Gaffer.Expression() for p, e, v in zip(s["n"]["user"].children(), defaultExpressions, expectedValues): s["e"].setExpression(e, "OSL") self.assertEqual(p.getValue(), v)
def __init__(self, name="LDTGetBoundingBox"): super(LDTGetBoundingBox, self).__init__(name) # create a Gaffer scene reader # connect the reader's output to the output self.setName("BoundBoxReader") self["in"] = GafferScene.ScenePlug(direction=Gaffer.Plug.Direction.In) # Make path read only for now # TODO: check if path exists # TODO: get bounding box in world space self["path"] = Gaffer.StringPlug() self["path"].setValue("/") self["bound"] = Gaffer.Box3fPlug() Gaffer.Metadata.registerValue(self["bound"], 'readOnly', True) self["boundDiagonalLength"] = Gaffer.FloatPlug() Gaffer.Metadata.registerValue(self["boundDiagonalLength"], 'readOnly', True) self["boundSize"] = Gaffer.V3fPlug() Gaffer.Metadata.registerValue(self["boundSize"], 'readOnly', True) self["boundCenter"] = Gaffer.V3fPlug() Gaffer.Metadata.registerValue(self["boundCenter"], 'readOnly', True) self["out"] = GafferScene.ScenePlug( direction=Gaffer.Plug.Direction.Out) self["out"].setFlags(Gaffer.Plug.Flags.Serialisable, False) self["out"].setInput(self["in"]) self.__plugInputChanged = self.plugInputChangedSignal().connect( self.get_bound) self.__plugValueChanged = self.plugSetSignal().connect(self.get_bound)
def testRanges( self ) : n = Gaffer.Node() n["c1"] = Gaffer.Plug() n["c2"] = Gaffer.Node() n["c3"] = Gaffer.IntPlug() n["c4"] = Gaffer.Plug() n["c4"]["gc1"] = Gaffer.Plug() n["c4"]["gc2"] = Gaffer.FloatPlug() self.assertEqual( list( Gaffer.IntPlug.Range( n ) ), [ n["c3"] ] ) self.assertEqual( list( Gaffer.FloatPlug.Range( n ) ), [] ) self.assertEqual( list( Gaffer.IntPlug.RecursiveRange( n ) ), [ n["c3"] ] ) self.assertEqual( list( Gaffer.FloatPlug.RecursiveRange( n ) ), [ n["c4"]["gc2"] ] )
def testDirtyPropagation(self): s = Gaffer.Spreadsheet() s["rows"].addColumn(Gaffer.V3fPlug("v")) s["rows"].addColumn(Gaffer.FloatPlug("f")) r = s["rows"].addRow() cs = GafferTest.CapturingSlot(s.plugDirtiedSignal()) s["enabled"].setValue(False) self.assertTrue(set(s["out"].children()).issubset({x[0] for x in cs})) del cs[:] r["cells"]["v"]["value"]["x"].setValue(2) self.assertIn(s["out"]["v"]["x"], {x[0] for x in cs}) self.assertNotIn(s["out"]["v"]["z"], {x[0] for x in cs}) self.assertNotIn(s["out"]["f"], {x[0] for x in cs}) del cs[:] r["cells"]["v"]["enabled"].setValue(False) self.assertTrue( set(s["out"]["v"].children()).issubset({x[0] for x in cs})) self.assertNotIn(s["out"]["f"], {x[0] for x in cs}) del cs[:] s["rows"].addRow() self.assertTrue(set(s["out"].children()).issubset({x[0] for x in cs})) del cs[:] s["rows"].removeChild(s["rows"][-1]) self.assertTrue(set(s["out"].children()).issubset({x[0] for x in cs})) del cs[:]
def testImageProcessingFunctions(self): oslCode = GafferOSL.OSLCode() oslCode["out"]["out"] = Gaffer.FloatPlug( direction=Gaffer.Plug.Direction.Out, flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) self.__assertNoError(oslCode, oslCode["code"].setValue, 'out = inChannel( "R", 0 );')
def __init__( self, name = "Wedge" ) : GafferDispatch.TaskContextProcessor.__init__( self, name ) self["variable"] = Gaffer.StringPlug( defaultValue = "wedge:value" ) self["indexVariable"] = Gaffer.StringPlug( defaultValue = "wedge:index" ) self["mode"] = Gaffer.IntPlug( defaultValue = int( self.Mode.FloatRange ), minValue = int( self.Mode.FloatRange ), maxValue = int( self.Mode.StringList ), ) # float range self["floatMin"] = Gaffer.FloatPlug( defaultValue = 0 ) self["floatMax"] = Gaffer.FloatPlug( defaultValue = 1 ) self["floatSteps"] = Gaffer.IntPlug( minValue = 2, defaultValue = 11 ) # int range self["intMin"] = Gaffer.IntPlug( defaultValue = 0 ) self["intMax"] = Gaffer.IntPlug( defaultValue = 5 ) self["intStep"] = Gaffer.IntPlug( minValue = 1, defaultValue = 1 ) # color range self["ramp"] = Gaffer.SplinefColor3fPlug( defaultValue = IECore.SplinefColor3f( IECore.CubicBasisf.catmullRom(), ( ( 0, imath.Color3f( 0 ) ), ( 0, imath.Color3f( 0 ) ), ( 1, imath.Color3f( 1 ) ), ( 1, imath.Color3f( 1 ) ), ) ) ) self["colorSteps"] = Gaffer.IntPlug( defaultValue = 5, minValue = 2 ) # lists self["floats"] = Gaffer.FloatVectorDataPlug( defaultValue = IECore.FloatVectorData() ) self["ints"] = Gaffer.IntVectorDataPlug( defaultValue = IECore.IntVectorData() ) self["strings"] = Gaffer.StringVectorDataPlug( defaultValue = IECore.StringVectorData() )
def testRemoveMiddleColumn(self): s = Gaffer.ScriptNode() s["s"] = Gaffer.Spreadsheet() s["s"]["rows"].addRow() c1 = s["s"]["rows"].addColumn(Gaffer.IntPlug("c1")) c2 = s["s"]["rows"].addColumn(Gaffer.FloatPlug("c2")) c3 = s["s"]["rows"].addColumn(Gaffer.StringPlug("c3")) def assertPreconditions(): for row in s["s"]["rows"]: self.assertEqual(row["cells"].keys(), ["c1", "c2", "c3"]) self.assertIsInstance(row["cells"]["c1"]["value"], Gaffer.IntPlug) self.assertIsInstance(row["cells"]["c2"]["value"], Gaffer.FloatPlug) self.assertIsInstance(row["cells"]["c3"]["value"], Gaffer.StringPlug) self.assertEqual(s["s"]["out"].keys(), ["c1", "c2", "c3"]) self.assertIsInstance(s["s"]["out"]["c1"], Gaffer.IntPlug) self.assertIsInstance(s["s"]["out"]["c2"], Gaffer.FloatPlug) self.assertIsInstance(s["s"]["out"]["c3"], Gaffer.StringPlug) assertPreconditions() with Gaffer.UndoScope(s): s["s"]["rows"].removeColumn(c2) def assertPostConditions(): for row in s["s"]["rows"]: self.assertEqual(row["cells"].keys(), ["c1", "c3"]) self.assertIsInstance(row["cells"]["c1"]["value"], Gaffer.IntPlug) self.assertIsInstance(row["cells"]["c3"]["value"], Gaffer.StringPlug) self.assertEqual(s["s"]["out"].keys(), ["c1", "c3"]) self.assertIsInstance(s["s"]["out"]["c1"], Gaffer.IntPlug) self.assertIsInstance(s["s"]["out"]["c3"], Gaffer.StringPlug) assertPostConditions() s.undo() assertPreconditions() s.redo() assertPostConditions() s.undo() assertPreconditions() s.redo() assertPostConditions()