def testSerialisationPlugAccumulation( self ) :
s = Gaffer.ScriptNode()
s["n"] = Gaffer.Node()
s["n"]["user"].addChild( Gaffer.FloatPlug( "f", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
s["e"] = Gaffer.Expression()
s["e"]["engine"].setValue( "python" )
s["e"]["expression"].setValue( "parent[\"n\"][\"user\"][\"f\"] = 2" )
self.assertEqual( s["n"]["user"]["f"].getValue(), 2 )
ss = s.serialise()
s2 = Gaffer.ScriptNode()
s2.execute( ss )
self.assertEqual( s2["n"]["user"]["f"].getValue(), 2 )
self.failUnless( s2["e"].getChild("out1") is None )
self.failUnless( s2["e"].getChild("in1") is None )
def testSerialisationCreationOrder(self):
# Create a script where the expression node is created before the nodes it's targeting,
# and make sure it still serialises/loads correctly.
s = Gaffer.ScriptNode()
s["e"] = Gaffer.Expression()
s["m1"] = GafferTest.MultiplyNode()
s["m1"]["op1"].setValue(10)
s["m1"]["op2"].setValue(20)
s["m2"] = GafferTest.MultiplyNode()
s["m2"]["op2"].setValue(1)
s["e"].setExpression(
"parent[\"m2\"][\"op1\"] = parent[\"m1\"][\"product\"] * 2",
"python")
self.assertEqual(s["m2"]["product"].getValue(), 400)
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s2["m2"]["product"].getValue(), 400)
def testGlobalContext( self ) : script = Gaffer.ScriptNode() script["shader"] = GafferSceneTest.TestShader() script["shader"]["type"].setValue( "shader" ) script["expression"] = Gaffer.Expression() script["expression"].setExpression( 'parent["shader"]["parameters"]["i"] = 1 if context.get( "scene:path", None ) else 0' ) script["sphere"] = GafferScene.Sphere() script["filter"] = GafferScene.PathFilter() script["filter"]["paths"].setValue( IECore.StringVectorData( [ "/sphere" ] ) ) script["assignment"] = GafferScene.ShaderAssignment() script["assignment"]["in"].setInput( script["sphere"]["out"] ) script["assignment"]["filter"].setInput( script["filter"]["out"] ) script["assignment"]["shader"].setInput( script["shader"]["out"] ) self.assertEqual( script["assignment"]["out"].attributes( "/sphere" )["shader"].outputShader().parameters["i"].value, 0 )
def testExpressions(self):
s = Gaffer.ScriptNode()
s["n1"] = Gaffer.Node()
s["n2"] = Gaffer.Node()
s["n1"]["user"]["f"] = GafferImage.AtomicFormatPlug(
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
s["n2"]["user"]["f"] = GafferImage.AtomicFormatPlug(
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
s["e"] = Gaffer.Expression()
s["e"].setExpression(
'f = parent["n1"]["user"]["f"]; b = f.getDisplayWindow(); b.setMin( b.min() - imath.V2i( 10 ) ); b.setMax( b.max() + imath.V2i( 20 ) ); f.setPixelAspect( 0.5 ); f.setDisplayWindow( b ); parent["n2"]["user"]["f"] = f'
)
s["n1"]["user"]["f"].setValue(
GafferImage.Format(
imath.Box2i(imath.V2i(20, 30), imath.V2i(100, 110)), 1))
self.assertEqual(
s["n2"]["user"]["f"].getValue(),
GafferImage.Format(
imath.Box2i(imath.V2i(10, 20), imath.V2i(120, 130)), 0.5))
def testImathContextVariable( self ) :
s = Gaffer.ScriptNode()
s["t"] = GafferDispatchTest.TextWriter()
s["t"]["fileName"].setValue( self.temporaryDirectory() + "/test.txt" )
s["e"] = Gaffer.Expression()
s["e"].setExpression( inspect.cleandoc(
"""
c = context["c"]
parent["t"]["text"] = "{0} {1} {2}".format( *c )
"""
) )
s["fileName"].setValue( self.temporaryDirectory() + "/test.gfr" )
s.save()
subprocess.check_call( [ "gaffer", "execute", s["fileName"].getValue(), "-context", "c", "imath.Color3f( 0, 1, 2 )" ] )
self.assertEqual(
open( s["t"]["fileName"].getValue() ).read(),
"0.0 1.0 2.0"
)
def testCancellationDuringCompute(self):
s = Gaffer.ScriptNode()
s["n"] = GafferTest.AddNode()
s["e"] = Gaffer.Expression()
s["e"].setExpression(
inspect.cleandoc("""
IECore.Canceller.check( context.canceller() )
parent['n']['op1'] = 40
"""))
canceller = IECore.Canceller()
canceller.cancel()
with Gaffer.Context(s.context(), canceller):
with self.assertRaises(IECore.Cancelled):
s["n"]["sum"].getValue()
canceller = IECore.Canceller()
with Gaffer.Context(s.context(), canceller):
self.assertEqual(s["n"]["sum"].getValue(), 40)
def testBackgroundDispatch(self):
script = Gaffer.ScriptNode()
script["writer"] = GafferDispatchTest.TextWriter()
script["expression"] = Gaffer.Expression()
script["expression"].setExpression(
'parent.writer.fileName = "' + self.temporaryDirectory() +
'/test.txt"', "OSL")
dispatcher = GafferDispatch.LocalDispatcher(
jobPool=GafferDispatch.LocalDispatcher.JobPool())
dispatcher["jobsDirectory"].setValue(
"/tmp/gafferOSLExpressionEngineTest/jobs")
dispatcher["executeInBackground"].setValue(True)
dispatcher.dispatch([script["writer"]])
dispatcher.jobPool().waitForAll()
self.assertEqual(len(dispatcher.jobPool().failedJobs()), 0)
self.assertTrue(os.path.exists(self.temporaryDirectory() +
"/test.txt"))
def test(self):
s = Gaffer.ScriptNode()
s["m"] = GafferTest.MultiplyNode()
s["m"]["op2"].setValue(1)
s["e"] = Gaffer.Expression()
s["e"].setExpression(
"parent[\"m\"][\"op1\"] = int( context[\"frame\"] )")
s["w"] = Gaffer.TimeWarp()
s["w"].setup(Gaffer.IntPlug())
s["w"]["in"].setInput(s["m"]["product"])
s["w"]["offset"].setValue(2)
s["w"]["speed"].setValue(2)
for i in range(0, 10):
c = Gaffer.Context()
c.setFrame(i)
with c:
self.assertEqual(s["m"]["product"].getValue(), i)
self.assertEqual(s["w"]["out"].getValue(), i * 2 + 2)
def testDeleteExpressionText(self):
s = Gaffer.ScriptNode()
s["m1"] = GafferTest.MultiplyNode()
s["m1"]["op1"].setValue(10)
s["m1"]["op2"].setValue(20)
s["m2"] = GafferTest.MultiplyNode()
s["m2"]["op2"].setValue(1)
s["e"] = Gaffer.Expression()
s["e"]["engine"].setValue("python")
s["e"].setExpression(
"parent[\"m2\"][\"op1\"] = parent[\"m1\"][\"product\"] * 2")
self.failUnless(s["m2"]["op1"].getInput().node().isSame(s["e"]))
self.assertEqual(s["m2"]["product"].getValue(), 400)
s["e"].setExpression("")
self.failUnless(s["m2"]["op1"].getInput() is None)
self.assertEqual(s["m2"]["product"].getValue(), 0)
def testStringContextVariableComparison(self):
s = Gaffer.ScriptNode()
s["n"] = Gaffer.Node()
s["n"]["user"]["i"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
expression = inspect.cleandoc("""
string var = context( "str" );
parent.n.user.i = var == "abc";
""")
s["e"] = Gaffer.Expression()
s["e"].setExpression(expression, "OSL")
with Gaffer.Context() as c:
c["str"] = "xyz"
self.assertEqual(s["n"]["user"]["i"].getValue(), 0)
c["str"] = "abc"
self.assertEqual(s["n"]["user"]["i"].getValue(), 1)
def testSetsNeedContextEntry(self):
script = Gaffer.ScriptNode()
script["light"] = GafferArnold.ArnoldLight()
script["light"].loadShader("point_light")
script["expression"] = Gaffer.Expression()
script["expression"].setExpression(
"""parent["light"]["name"] = context["lightName"]""")
script["render"] = GafferArnold.ArnoldRender()
script["render"]["in"].setInput(script["light"]["out"])
script["render"]["mode"].setValue(
script["render"].Mode.SceneDescriptionMode)
script["render"]["fileName"].setValue(self.temporaryDirectory() +
"/test.ass")
for i in range(0, 100):
with Gaffer.Context() as context:
context["lightName"] = "light%d" % i
script["render"]["task"].execute()
def testSwitchWithComponentConnections(self):
s = Gaffer.ScriptNode()
s["n1"] = GafferSceneTest.TestShader("n1")
s["n2"] = GafferSceneTest.TestShader("n2")
s["n3"] = GafferSceneTest.TestShader("n3")
s["n3"]["type"].setValue("test:surface")
s["switch"] = Gaffer.Switch()
s["switch"].setup(s["n3"]["parameters"]["c"])
s["switch"]["in"][0].setInput(s["n1"]["out"])
s["switch"]["in"][1].setInput(s["n2"]["out"])
s["n3"]["parameters"]["c"]["r"].setInput(s["switch"]["out"]["r"])
s["expression"] = Gaffer.Expression()
s["expression"].setExpression(
'parent["switch"]["index"] = context["index"]')
with Gaffer.Context() as context:
for i in range(0, 3):
context["index"] = i
effectiveIndex = i % 2
network = s["n3"].attributes()["test:surface"]
self.assertEqual(len(network), 2)
self.assertEqual(network.inputConnections("n3"), [
network.Connection(
network.Parameter(
"n{0}".format(effectiveIndex + 1),
"r",
), network.Parameter("n3", "c.r"))
])
def testDuplicateDeserialise(self):
s = Gaffer.ScriptNode()
s["source"] = Gaffer.Node()
s["source"]["p"] = Gaffer.V3fPlug(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["source"]["p"].setValue(imath.V3f(0.1, 0.2, 0.3))
s["dest"] = Gaffer.Node()
s["dest"]["p"] = Gaffer.V3fPlug(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["e"] = Gaffer.Expression()
s["e"].setExpression(
"parent.dest.p.x = parent.source.p.x + 1;\n" +
"parent.dest.p.y = parent.source.p.y + 2;\n" +
"parent.dest.p.z = parent.source.p.z + 3;\n",
"OSL",
)
ss = s.serialise()
s.execute(ss)
s.execute(ss)
self.assertEqual(s["dest"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
self.assertEqual(s["dest1"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
self.assertEqual(s["dest2"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
# Working well so far, but we've had a bug that could be hidden by the caching. Lets
# try evaluating the plugs again, but flushing the cache each time
Gaffer.ValuePlug.clearCache()
self.assertEqual(s["dest"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
self.assertEqual(s["dest1"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
self.assertEqual(s["dest2"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
def _createTraceSetShader( self ) :
# It's currently pretty ugly how we need to disable the trace set when it is left empty,
# to match the behaviour expected by GafferSceneTest.InteractiveRenderTest.
# Would be somewhat cleaner if we had the primaryInput metadata on trace_set
# available, so we could just put an expression on it to disable it when no trace set is given,
# but it doesn't seem very safe to do a metadata load in the middle of the tests
shaderBox = Gaffer.Box()
shader = GafferArnold.ArnoldShader("shader")
shader.loadShader( "standard_surface" )
shader["parameters"]["base"].setValue( 1 )
shader["parameters"]["specular_roughness"].setValue( 0 )
shader["parameters"]["metalness"].setValue( 1 )
shader["parameters"]["specular_IOR"].setValue( 100 )
#return shader, Gaffer.StringPlug( "unused" )
traceSetShader = GafferArnold.ArnoldShader("traceSetShader")
traceSetShader.loadShader( "trace_set" )
traceSetShader["parameters"]["passthrough"].setInput( shader["out"] )
switchShader = GafferArnold.ArnoldShader("switchShader")
switchShader.loadShader( "switch_shader" )
switchShader["parameters"]["input0"].setInput( shader["out"] )
switchShader["parameters"]["input1"].setInput( traceSetShader["out"] )
shaderBox.addChild( shader )
shaderBox.addChild( traceSetShader )
shaderBox.addChild( switchShader )
shaderBox["enableExpression"] = Gaffer.Expression()
shaderBox["enableExpression"].setExpression( 'parent.switchShader.parameters.index = parent.traceSetShader.parameters.trace_set != ""', "OSL" )
Gaffer.PlugAlgo.promote( switchShader["out"] )
return shaderBox, traceSetShader["parameters"]["trace_set"]
def testDisabling(self):
script = Gaffer.ScriptNode()
script["constant"] = GafferImage.Constant()
script["expression"] = Gaffer.Expression()
script["expression"].setExpression(
'parent["constant"]["color"]["r"] = context["frame"]')
script["timeWarp"] = Gaffer.TimeWarp()
script["timeWarp"].setup(GafferImage.ImagePlug())
script["timeWarp"]["offset"].setValue(1)
script["timeWarp"]["in"].setInput(script["constant"]["out"])
with script.context():
c = script["constant"]["out"].image()
cHash = script["constant"]["out"].imageHash()
t = script["timeWarp"]["out"].image()
tHash = script["timeWarp"]["out"].imageHash()
self.assertNotEqual(c, t)
self.assertNotEqual(cHash, tHash)
script["timeWarp"]["enabled"].setValue(False)
with script.context():
c = script["constant"]["out"].image()
cHash = script["constant"]["out"].imageHash()
t = script["timeWarp"]["out"].image()
tHash = script["timeWarp"]["out"].imageHash()
self.assertEqual(c, t)
self.assertEqual(cHash, tHash)
def testMoreThanTenPlugs(self):
s = Gaffer.ScriptNode()
expression = ""
for i in range(0, 20):
aName = "A%d" % i
bName = "B%d" % i
s[aName] = Gaffer.Node()
s[bName] = Gaffer.Node()
s[aName]["user"]["p"] = Gaffer.IntPlug(
defaultValue=i,
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
s[bName]["user"]["p"] = Gaffer.IntPlug(
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
expression += "parent.%s.user.p = parent.%s.user.p;\n" % (bName,
aName)
s["e"] = Gaffer.Expression()
s["e"].setExpression(expression, "OSL")
self.assertEqual(s["e"].getExpression(), (expression, "OSL"))
for i in range(0, 20):
self.assertEqual(s["B%d" % i]["user"]["p"].getValue(), i)
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s2["e"].getExpression(), (expression, "OSL"))
for i in range(0, 20):
self.assertEqual(s2["B%d" % i]["user"]["p"].getValue(), i)
def __init__(self, name="_ObjectPreview"):
Gaffer.Node.__init__(self, name)
self["fileName"] = Gaffer.StringPlug(
defaultValue="",
substitutions=Gaffer.Context.Substitutions.NoSubstitutions)
self["frameRate"] = Gaffer.FloatPlug(defaultValue=24.0)
self["samplesPerFrame"] = Gaffer.IntPlug(defaultValue=1, minValue=1)
# single object scenes using Reader ops behind the scenes?
self["ObjectReader"] = Gaffer.ObjectReader()
self["ObjectReaderExpression"] = Gaffer.Expression("Expression")
self["ObjectReaderExpression"].setExpression('''
import IECore
fileName = parent['fileName']
try :
sequence = IECore.FileSequence( fileName )
calc = IECore.OversamplesCalculator( frameRate = parent["frameRate"], samplesPerFrame = parent["samplesPerFrame"] )
if isinstance( sequence.frameList, IECore.FrameRange ) and sequence.frameList.step == 1 :
calc.setTicksPerSecond( 24 )
result = sequence.fileNameForFrame( calc.framesToTicks( context['frame'] ) )
except :
result = fileName
parent['ObjectReader']['fileName'] = result
''')
self["ObjectToScene"] = GafferScene.ObjectToScene("ObjectToScene")
self["ObjectToScene"]["object"].setInput(self["ObjectReader"]["out"])
self["out"] = GafferScene.ScenePlug(
direction=Gaffer.Plug.Direction.Out)
self["out"].setInput(self["ObjectToScene"]["out"])
def testEnabled(self):
s = Gaffer.ScriptNode()
s["m"] = GafferTest.MultiplyNode()
s["m"]["op2"].setValue(1)
s["e"] = Gaffer.Expression()
s["e"]["engine"].setValue("python")
s["e"]["expression"].setValue(
"parent[\"m\"][\"op1\"] = int( context[\"frame\"] )")
s["w"] = Gaffer.TimeWarpComputeNode()
s["w"]["in"] = Gaffer.IntPlug()
s["w"]["in"].setInput(s["m"]["product"])
s["w"]["out"] = Gaffer.IntPlug(direction=Gaffer.Plug.Direction.Out)
s["w"]["offset"].setValue(2)
# test that enabledPlug() and correspondingInput() are implemented
self.assertTrue(s["w"].enabledPlug().isSame(s["w"]["enabled"]))
self.assertTrue(s["w"].correspondingInput(s["w"]["out"]).isSame(
s["w"]["in"]))
# test that disabling causes no time warping
s["w"]["enabled"].setValue(False)
for i in range(0, 10):
with Gaffer.Context() as c:
c.setFrame(i)
self.assertEqual(s["m"]["product"].getValue(),
s["w"]["out"].getValue())
self.assertEqual(s["m"]["product"].hash(),
s["w"]["out"].hash())
def __init__(self, name="Scale"):
GafferImage.ImageProcessor.__init__(self, name)
self["factor"] = Gaffer.FloatPlug(defaultValue=1, minValue=0)
self["filter"] = Gaffer.StringPlug(defaultValue="sharp-gaussian")
self["__Resize"] = GafferImage.Resize()
self["__Resize"]["filter"].setInput(self["filter"])
self["__Resize"]["in"].setInput(self["in"])
self["out"].setInput(self["__Resize"]["out"])
self["__Expression"] = Gaffer.Expression()
self["__Expression"].setExpression(
inspect.cleandoc("""
format = parent["__Resize"]["in"]["format"]
w = format.getDisplayWindow()
parent["__Resize"]["format"]["displayWindow"]["min"]["x"] = parent["factor"] * w.min().x
parent["__Resize"]["format"]["displayWindow"]["min"]["y"] = parent["factor"] * w.min().y
parent["__Resize"]["format"]["displayWindow"]["max"]["x"] = parent["factor"] * w.max().x
parent["__Resize"]["format"]["displayWindow"]["max"]["y"] = parent["factor"] * w.max().y
parent["__Resize"]["format"]["pixelAspect"] = format.getPixelAspect()
"""), "python")
def testIdentifier(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["n"]["user"]["s"] = Gaffer.SplineffPlug(
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
s["e"] = Gaffer.Expression()
s["e"].setExpression("", "OSL")
# We should be able to set up an expression via script without needing to know
# the convention for addressing plugs.
s["e"].setExpression(
"%s = %s + 1;" % (s["e"].identifier(
s["n"]["user"]["o"]), s["e"].identifier(s["n"]["user"]["i"])),
"OSL")
self.assertEqual(s["n"]["user"]["o"].getValue(), 1)
# Plug type isn't supported, so should return empty string.
self.assertEqual(s["e"].identifier(s["n"]["user"]["s"]), "")
def testContextParameter(self):
s = Gaffer.ScriptNode()
s["write"] = GafferDispatchTest.TextWriter()
s["write"]["fileName"].setValue(self.__outputFileSeq.fileName)
s["e"] = Gaffer.Expression()
s["e"].setExpression(
"parent['write']['text'] = '{} {}'.format( context.get( 'valueOne', 0 ), context.get( 'valueTwo', 0 ) )"
)
s["fileName"].setValue(self.__scriptFileName)
s.save()
self.assertFalse(
os.path.exists(self.__outputFileSeq.fileNameForFrame(1)))
p = subprocess.Popen(
"gaffer execute " + self.__scriptFileName +
" -context -valueOne 1 -valueTwo 2",
shell=True,
stderr=subprocess.PIPE,
universal_newlines=True,
)
p.wait()
error = "".join(p.stderr.readlines())
self.assertEqual(error, "")
self.assertFalse(p.returncode)
self.assertTrue(
os.path.exists(self.__outputFileSeq.fileNameForFrame(1)))
with open(self.__outputFileSeq.fileNameForFrame(1)) as f:
string = f.read()
self.assertEqual(string, "1 2")
def testStringVectorDataPlug(self):
s = Gaffer.ScriptNode()
s["n"] = Gaffer.Node()
s["n"]["user"].addChild(
Gaffer.StringVectorDataPlug("p",
defaultValue=IECore.StringVectorData(),
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic))
s["e"] = Gaffer.Expression()
s["e"].setExpression(
'import IECore; parent["n"]["user"]["p"] = IECore.StringVectorData( [ "one", "two" ] )'
)
self.assertEqual(s["n"]["user"]["p"].getValue(),
IECore.StringVectorData(["one", "two"]))
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s2["n"]["user"]["p"].getValue(),
IECore.StringVectorData(["one", "two"]))
def testContextCompatibility(self):
script = Gaffer.ScriptNode()
# Network to assign the existence of "scene:path" as a primvar called "id"
script["outInt"] = GafferOSL.OSLShader()
script["outInt"].loadShader("ObjectProcessing/OutInt")
script["outObject"] = GafferOSL.OSLShader()
script["outObject"].loadShader("ObjectProcessing/OutObject")
script["outObject"]["parameters"]["in0"].setInput(
script["outInt"]["out"]["primitiveVariable"])
script["expression"] = Gaffer.Expression()
script["expression"].setExpression(
'parent["outInt"]["parameters"]["value"] = 1 if context.get( "scene:path", None ) else 0'
)
# OSLObject node to apply network
script["plane"] = GafferScene.Plane()
script["filter"] = GafferScene.PathFilter()
script["filter"]["paths"].setValue(IECore.StringVectorData(["/plane"]))
script["oslObject"] = GafferOSL.OSLObject()
script["oslObject"]["in"].setInput(script["plane"]["out"])
script["oslObject"]["filter"].setInput(script["filter"]["out"])
script["oslObject"]["shader"].setInput(
script["outObject"]["out"]["out"])
# Check that "scene:path" isn't exposed to the shader
self.assertEqual(
script["oslObject"]["out"].object("/plane")["id"].data[0], 0)
def testParseFailureLeavesStateUnchanged( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["i"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["e"] = Gaffer.Expression() s["e"].setExpression( "parent['n']['user']['i'] = context.getFrame()" ) cs = GafferTest.CapturingSlot( s["e"].expressionChangedSignal() ) with Gaffer.Context() as c : c.setFrame( 10 ) self.assertEqual( s["n"]["user"]["i"].getValue(), 10 ) c.setFrame( 20 ) self.assertEqual( s["n"]["user"]["i"].getValue(), 20 ) with Gaffer.UndoScope( s ) : self.assertRaisesRegexp( Exception, "SyntaxError", s["e"].setExpression, "i'm not valid python" ) self.assertEqual( len( cs ), 0 ) self.assertFalse( s.undoAvailable() ) with Gaffer.Context() as c : c.setFrame( 11 ) self.assertEqual( s["n"]["user"]["i"].getValue(), 11 ) c.setFrame( 21 ) self.assertEqual( s["n"]["user"]["i"].getValue(), 21 )
def testNoDefaultExpressionForUnsupportedPlugs( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"].addChild( Gaffer.SplineffPlug( defaultValue = IECore.Splineff( IECore.CubicBasisf.linear(), ( ( 0, 0 ), ( 1, 1 ), ), ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.TransformPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Transform2DPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.ValuePlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["e"] = Gaffer.Expression() for plug in s["n"]["user"] : self.assertEqual( s["e"].defaultExpression( plug, "python" ), "" )
def testPathPlugExpression(self):
s = Gaffer.ScriptNode()
s["f"] = GafferScene.PathFilter()
s["e"] = Gaffer.Expression()
s["e"]["engine"].setValue("python")
s["e"]["expression"].setValue(
"import IECore\n"
"passName = context.get( 'passName', '' )\n"
"if passName == 'foreground' :\n"
" paths = IECore.StringVectorData( [ '/a' ] )\n"
"else :\n"
" paths = IECore.StringVectorData( [ '/b' ] )\n"
"parent['f']['paths'] = paths")
with Gaffer.Context() as c:
c["scene:path"] = IECore.InternedStringVectorData(["a"])
self.assertEqual(s["f"]["match"].getValue(),
GafferScene.Filter.Result.NoMatch)
c["passName"] = "foreground"
self.assertEqual(s["f"]["match"].getValue(),
GafferScene.Filter.Result.ExactMatch)
def testSerialisation( self ) : s = Gaffer.ScriptNode() s["m1"] = GafferTest.MultiplyNode() s["m1"]["op1"].setValue( 10 ) s["m1"]["op2"].setValue( 20 ) s["m2"] = GafferTest.MultiplyNode() s["m2"]["op2"].setValue( 1 ) s["e"] = Gaffer.Expression() s["e"]["engine"].setValue( "python" ) s["e"]["expression"].setValue( "parent[\"m2\"][\"op1\"] = parent[\"m1\"][\"product\"] * 2" ) self.assertEqual( s["m2"]["product"].getValue(), 400 ) ss = s.serialise() s2 = Gaffer.ScriptNode() s2.execute( ss ) self.assertEqual( s2["m2"]["product"].getValue(), 400 )
def testExecute(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["render"] = GafferAppleseed.AppleseedRender()
s["render"]["mode"].setValue(s["render"].Mode.SceneDescriptionMode)
s["render"]["in"].setInput(s["plane"]["out"])
s["expression"] = Gaffer.Expression()
s["expression"].setExpression(
"parent['render']['fileName'] = '" + self.temporaryDirectory() +
"/test.%d.appleseed' % int( context['frame'] )")
s["fileName"].setValue(self.__scriptFileName)
s.save()
subprocess.check_call(
["gaffer", "execute", self.__scriptFileName, "-frames", "1-3"])
for i in range(1, 4):
self.failUnless(
os.path.exists(self.temporaryDirectory() +
"/test.%d.appleseed" % i))
def __createExpression(plug):
node = plug.node()
parentNode = node.ancestor(Gaffer.Node.staticTypeId())
with Gaffer.UndoContext(node.scriptNode()):
expressionNode = Gaffer.Expression()
parentNode.addChild(expressionNode)
expression = "parent['"
expression += plug.relativeName(parentNode).replace(".", "']['")
expression += "'] = "
if isinstance(plug, Gaffer.StringPlug):
expression += "''"
elif isinstance(plug, Gaffer.IntPlug):
expression += "1"
elif isinstance(plug, Gaffer.FloatPlug):
expression += "1.0"
expressionNode["expression"].setValue(expression)
__editExpression(plug)
def testUndo( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["a"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n"]["user"]["b"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n"]["user"]["c"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["e"] = Gaffer.Expression() s["e"]["engine"].setValue( "python" ) s["e"]["expression"].setValue( 'parent["n"]["user"]["a"] = 1; parent["n"]["user"]["b"] = 2; parent["n"]["user"]["c"] = 3' ) self.assertEqual( s["n"]["user"]["a"].getValue(), 1 ) self.assertEqual( s["n"]["user"]["b"].getValue(), 2 ) self.assertEqual( s["n"]["user"]["c"].getValue(), 3 ) with Gaffer.UndoContext( s ) : s["e"]["expression"].setValue( 'parent["n"]["user"]["c"] = 1; parent["n"]["user"]["b"] = 2; parent["n"]["user"]["a"] = 3' ) self.assertEqual( s["n"]["user"]["a"].getValue(), 3 ) self.assertEqual( s["n"]["user"]["b"].getValue(), 2 ) self.assertEqual( s["n"]["user"]["c"].getValue(), 1 ) s.undo() self.assertEqual( s["n"]["user"]["a"].getValue(), 1 ) self.assertEqual( s["n"]["user"]["b"].getValue(), 2 ) self.assertEqual( s["n"]["user"]["c"].getValue(), 3 ) s.redo() self.assertEqual( s["n"]["user"]["a"].getValue(), 3 ) self.assertEqual( s["n"]["user"]["b"].getValue(), 2 ) self.assertEqual( s["n"]["user"]["c"].getValue(), 1 )
