Ejemplo n.º 1
0
	def testPromoteDynamicBoxPlugAndSerialise( self ) :

		s = Gaffer.ScriptNode()
		s["b"] = Gaffer.Box()
		s["b"]["n"] = Gaffer.Node()
		s["b"]["n"]["p"] = Gaffer.Box2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic )

		p = s["b"].promotePlug( s["b"]["n"]["p"] )
		p.setValue( IECore.Box2i( IECore.V2i( 1, 2 ), IECore.V2i( 3, 4 ) ) )
		p.setName( "c" )

		self.assertTrue( isinstance( s["b"]["c"], Gaffer.Box2iPlug ) )
		self.assertTrue( s["b"]["n"]["p"].getInput().isSame( s["b"]["c"] ) )
		self.assertTrue( s["b"]["n"]["p"]["min"].getInput().isSame( s["b"]["c"]["min"] ) )
		self.assertTrue( s["b"]["n"]["p"]["max"].getInput().isSame( s["b"]["c"]["max"] ) )
		self.assertEqual( s["b"]["c"].getValue(), IECore.Box2i( IECore.V2i( 1, 2 ), IECore.V2i( 3, 4 ) ) )

		s2 = Gaffer.ScriptNode()
		s2.execute( s.serialise() )

		self.assertTrue( isinstance( s2["b"]["c"], Gaffer.Box2iPlug ) )
		self.assertTrue( s2["b"]["n"]["p"].getInput().isSame( s2["b"]["c"] ) )
		self.assertTrue( s2["b"]["n"]["p"]["min"].getInput().isSame( s2["b"]["c"]["min"] ) )
		self.assertTrue( s2["b"]["n"]["p"]["max"].getInput().isSame( s2["b"]["c"]["max"] ) )
		self.assertEqual( s2["b"]["c"].getValue(), IECore.Box2i( IECore.V2i( 1, 2 ), IECore.V2i( 3, 4 ) ) )
Ejemplo n.º 2
0
	def testBoxOutputs( self ) :

		s = Gaffer.ScriptNode()

		s["n"] = Gaffer.Node()
		s["n"]["user"].addChild( Gaffer.Box2fPlug( "b2f", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box2iPlug( "b2i", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box3fPlug( "b3f", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box3iPlug( "b3i", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )

		s["e"] = Gaffer.Expression()
		s["e"].setExpression(
			'import IECore;'
			'parent["n"]["user"]["b2f"] = IECore.Box2f( IECore.V2f( 1, 2 ), IECore.V2f( 3, 4 ) );'
			'parent["n"]["user"]["b2i"] = IECore.Box2i( IECore.V2i( 5, 6 ), IECore.V2i( 7, 8 ) );'
			'parent["n"]["user"]["b3f"] = IECore.Box3f( IECore.V3f( 9, 10, 11 ), IECore.V3f( 12, 13, 14 ) );'
			'parent["n"]["user"]["b3i"] = IECore.Box3i( IECore.V3i( 15, 16, 17 ), IECore.V3i( 18, 19, 20 ) );'
		)

		def assertExpectedValues( script ) :

			self.assertEqual( script["n"]["user"]["b2f"].getValue(), IECore.Box2f( IECore.V2f( 1, 2 ), IECore.V2f( 3, 4 ) ) )
			self.assertEqual( script["n"]["user"]["b2i"].getValue(), IECore.Box2i( IECore.V2i( 5, 6 ), IECore.V2i( 7, 8 ) ) )
			self.assertEqual( script["n"]["user"]["b3f"].getValue(), IECore.Box3f( IECore.V3f( 9, 10, 11 ), IECore.V3f( 12, 13, 14 ) ) )
			self.assertEqual( script["n"]["user"]["b3i"].getValue(), IECore.Box3i( IECore.V3i( 15, 16, 17 ), IECore.V3i( 18, 19, 20 ) ) )

		assertExpectedValues( s )

		s2 = Gaffer.ScriptNode()
		s2.execute( s.serialise() )

		assertExpectedValues( s2 )
Ejemplo n.º 3
0
	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 )
Ejemplo n.º 4
0
	def testDefaultValueSerialisation( self ) :

		s = Gaffer.ScriptNode()
		s["s"] = Gaffer.Spreadsheet()
		s["s"]["rows"].addColumn( Gaffer.V3iPlug( "c1", defaultValue = imath.V3i( 1, 2, 3 ) ) )
		s["s"]["rows"].addColumn( Gaffer.Box2iPlug( "c2", defaultValue = imath.Box2i( imath.V2i( 0 ), imath.V2i( 1 ) ) ) )
		s["s"]["rows"].addRows( 3 )

		# Change defaults for some plugs

		s["s"]["rows"][1]["name"].setValue( "testName" )
		s["s"]["rows"][1]["cells"]["c1"]["value"].setValue( imath.V3i( 4, 5, 6 ) )
		s["s"]["rows"][2]["enabled"].setValue( False )
		s["s"]["rows"][2]["cells"]["c1"]["value"]["x"].setValue( 10 )
		s["s"]["rows"][3]["cells"]["c1"]["enabled"].setValue( False )
		s["s"]["rows"][3]["cells"]["c2"]["value"].setValue( imath.Box2i( imath.V2i( 10 ), imath.V2i( 11 ) ) )
		s["s"]["rows"][1]["name"].resetDefault()

		# Change values for some plugs, some of which also had their
		# defaults changed.

		s["s"]["rows"][1]["name"].setValue( "testName2" )
		s["s"]["rows"][1]["cells"]["c1"]["value"]["x"].setValue( 7 )
		s["s"]["rows"][3]["enabled"].setValue( False )

		# Check that everything round-trips correctly through a serialisation and load.

		s2 = Gaffer.ScriptNode()
		s2.execute( s.serialise() )

		self.assertEqual( s["s"]["rows"].defaultHash(), s2["s"]["rows"].defaultHash() )
		self.assertEqual( s["s"]["rows"].hash(), s2["s"]["rows"].hash() )
Ejemplo n.º 5
0
	def testValueSerialisation( self ) :

		s = Gaffer.ScriptNode()
		s["n"] = Gaffer.Node()
		s["n"]["user"]["b"] = Gaffer.Box2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic )
		s["n"]["user"]["i"] = Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic )

		def assertExpectedValues( numSetValueCalls ) :

			ss = s.serialise( filter = Gaffer.StandardSet( { s["n"] } ) )
			self.assertEqual( ss.count( "setValue" ), numSetValueCalls )

			s2 = Gaffer.ScriptNode()
			s2.execute( ss )

			self.assertEqual( s2["n"]["user"]["b"].getValue(), s["n"]["user"]["b"].getValue() )

		assertExpectedValues( 0 )

		s["n"]["user"]["b"].setValue( imath.Box2i( imath.V2i( 1, 2 ), imath.V2i( 3, 4 ) ) )
		assertExpectedValues( 1 ) # One setValue() call for plug b.

		s["n"]["user"]["b"]["min"]["x"].setInput( s["n"]["user"]["i"] )
		assertExpectedValues( 2 ) # One setValue() call for b.min.y, another for b.max.

		s["n"]["user"]["b"]["max"]["x"].setInput( s["n"]["user"]["i"] )
		assertExpectedValues( 2 ) # One setValue() call for b.min.y, another for b.max.y.

		s["n"]["user"]["b"]["max"]["y"].setInput( s["n"]["user"]["i"] )
		assertExpectedValues( 1 ) # One setValue() call for b.min.y

		s["n"]["user"]["b"]["min"]["y"].setInput( s["n"]["user"]["i"] )
		assertExpectedValues( 0 ) # All leaf plugs have inputs, so no setValue() calls needed.
Ejemplo n.º 6
0
    def testNoRedundantSetInputCalls(self):

        s = Gaffer.ScriptNode()
        s["n"] = Gaffer.Node()
        s["n"]["user"]["b1"] = Gaffer.Box2iPlug(flags=Gaffer.Plug.Flags.Default
                                                | Gaffer.Plug.Flags.Dynamic)
        s["n"]["user"]["b2"] = Gaffer.Box2iPlug(flags=Gaffer.Plug.Flags.Default
                                                | Gaffer.Plug.Flags.Dynamic)

        def assertExpectedInputs(numSetInputCalls):

            ss = s.serialise()
            self.assertEqual(ss.count("setInput"), numSetInputCalls)

            s2 = Gaffer.ScriptNode()
            s2.execute(ss)

            for p2 in [s2["n"]["user"]["b2"]] + list(
                    Gaffer.Plug.RecursiveRange(s2["n"]["user"]["b2"])):
                p = s.descendant(p2.relativeName(s2))
                i2 = p2.getInput()
                if i2 is not None:
                    self.assertEqual(p.getInput().relativeName(s),
                                     i2.relativeName(s2))
                else:
                    self.assertIsNone(p.getInput())

        assertExpectedInputs(0)

        s["n"]["user"]["b2"]["min"]["x"].setInput(
            s["n"]["user"]["b1"]["min"]["y"])
        assertExpectedInputs(1)

        s["n"]["user"]["b2"]["max"]["y"].setInput(
            s["n"]["user"]["b1"]["max"]["x"])
        assertExpectedInputs(2)

        s["n"]["user"]["b2"]["max"].setInput(s["n"]["user"]["b1"]["max"])
        assertExpectedInputs(2)

        s["n"]["user"]["b2"].setInput(s["n"]["user"]["b1"])
        assertExpectedInputs(1)