def testFramesParameter(self):

        s = Gaffer.ScriptNode()
        s["sphere"] = GafferTest.SphereNode()
        s["write"] = Gaffer.ObjectWriter()
        s["write"]["in"].setInput(s["sphere"]["out"])
        s["write"]["fileName"].setValue(self.__outputFileSeq.fileName)

        s["fileName"].setValue(self.__scriptFileName)
        s.save()

        frames = IECore.FrameList.parse("1-5")
        for f in frames.asList():
            self.failIf(
                os.path.exists(self.__outputFileSeq.fileNameForFrame(f)))

        p = subprocess.Popen(
            "gaffer execute " + self.__scriptFileName + " -frames " +
            str(frames),
            shell=True,
            stderr=subprocess.PIPE,
        )
        p.wait()

        error = "".join(p.stderr.readlines())
        self.failUnless(error == "")
        self.failIf(p.returncode)
        for f in frames.asList():
            self.failUnless(
                os.path.exists(self.__outputFileSeq.fileNameForFrame(f)))
Пример #2
0
    def testContextParameter(self):

        s = Gaffer.ScriptNode()
        s["string"] = GafferTest.CachingTestNode()
        s["e"] = Gaffer.Expression()
        s["e"].setExpression(
            "parent['string']['in'] = '{} {}'.format( context.get( 'valueOne', 0 ), context.get( 'valueTwo', 0 ) )"
        )
        s["write"] = Gaffer.ObjectWriter()
        s["write"]["in"].setInput(s["string"]["out"])
        s["write"]["fileName"].setValue(self.__outputFileSeq.fileName)

        s["fileName"].setValue(self.__scriptFileName)
        s.save()

        self.failIf(os.path.exists(self.__outputFileSeq.fileNameForFrame(1)))
        p = subprocess.Popen(
            "gaffer execute " + self.__scriptFileName +
            " -context -valueOne 1 -valueTwo 2",
            shell=True,
            stderr=subprocess.PIPE,
        )
        p.wait()

        error = "".join(p.stderr.readlines())
        self.assertEqual(error, "")
        self.failIf(p.returncode)
        self.failUnless(
            os.path.exists(self.__outputFileSeq.fileNameForFrame(1)))

        string = IECore.ObjectReader(
            self.__outputFileSeq.fileNameForFrame(1)).read()
        self.failUnless(string.isInstanceOf(IECore.StringData))
        self.assertEqual(string.value, "1 2")
    def testExecuteObjectWriter(self):

        s = Gaffer.ScriptNode()

        s["sphere"] = GafferTest.SphereNode()
        s["write"] = Gaffer.ObjectWriter()
        s["write"]["in"].setInput(s["sphere"]["out"])
        s["write"]["fileName"].setValue(self.__outputFileSeq.fileName)

        s["fileName"].setValue(self.__scriptFileName)
        s.save()

        self.failIf(os.path.exists(self.__outputFileSeq.fileNameForFrame(1)))
        p = subprocess.Popen(
            "gaffer execute " + self.__scriptFileName,
            shell=True,
            stderr=subprocess.PIPE,
        )
        p.wait()

        error = "".join(p.stderr.readlines())
        self.failUnless(error == "")
        self.failUnless(
            os.path.exists(self.__outputFileSeq.fileNameForFrame(1)))
        self.failIf(p.returncode)
Пример #4
0
	def testContextParameter( self ) :
		
		s = Gaffer.ScriptNode()
		s["sphere"] = GafferTest.SphereNode()
		s["e"] = Gaffer.Expression()
		s["e"]["engine"].setValue( "python" )
		s["e"]["expression"].setValue( "parent['sphere']['radius'] = context.get( 'sphere:radius', 1 )" )
		s["e2"] = Gaffer.Expression()
		s["e2"]["engine"].setValue( "python" )
		s["e2"]["expression"].setValue( "parent['sphere']['theta'] = context.get( 'sphere:theta', 360 )" )
		s["write"] = Gaffer.ObjectWriter()
		s["write"]["in"].setInput( s["sphere"]["out"] )
		s["write"]["fileName"].setValue( self.__outputFileSeq.fileName )
		
		s["fileName"].setValue( self.__scriptFileName )
		s.save()		
		
		self.failIf( os.path.exists( self.__outputFileSeq.fileNameForFrame( 1 ) ) )
		p = subprocess.Popen(
			"gaffer execute " + self.__scriptFileName + " -context -sphere:radius 5 -sphere:theta 180",
			shell=True,
			stderr = subprocess.PIPE,
		)
		p.wait()
		
		error = "".join( p.stderr.readlines() )
		self.failUnless( error == "" )
		self.failIf( p.returncode )
		self.failUnless( os.path.exists( self.__outputFileSeq.fileNameForFrame( 1 ) ) )
		
		prim = IECore.ObjectReader( self.__outputFileSeq.fileNameForFrame( 1 ) ).read()
		self.failUnless( prim.isInstanceOf( IECore.SpherePrimitive.staticTypeId() ) )
		self.assertEqual( prim.bound(), IECore.Box3f( IECore.V3f( -5 ), IECore.V3f( 5 ) ) )
		self.assertEqual( prim.thetaMax(), 180 )
Пример #5
0
    def test(self):

        checker = os.path.dirname(__file__) + "/images/checker.exr"
        checker = IECore.Reader.create(checker).read()

        node = Gaffer.ObjectWriter()
        node["fileName"].setValue(self.__exrFileName)
        node["in"].setValue(checker)

        self.assertEqual(node["fileName"].getValue(), self.__exrFileName)
        self.assertEqual(node["in"].getValue(), checker)

        # check that there are plugs for the writer parameters,
        # but not for the fileName parameter.

        writer = IECore.Writer.create(checker, self.__exrFileName)

        for k in writer.parameters().keys():
            if k != "fileName" and k != "object":
                self.failUnless(k in node["parameters"])

        self.failIf("fileName" in node["parameters"])

        # check that saving it works

        self.failIf(os.path.exists(self.__exrFileName))
        node.execute([Gaffer.Context()])
        self.failUnless(os.path.exists(self.__exrFileName))

        checker2 = IECore.Reader.create(self.__exrFileName).read()
        self.assertEqual(checker, checker2)
Пример #6
0
    def testExecutionHash(self):

        c = Gaffer.Context()
        c.setFrame(1)
        c2 = Gaffer.Context()
        c2.setFrame(2)

        s = Gaffer.ScriptNode()
        s["n"] = Gaffer.ObjectWriter()

        # no file produces no effect
        self.assertEqual(s["n"].executionHash(c), IECore.MurmurHash())

        # no input object produces no effect
        s["n"]["fileName"].setValue(self.__exrFileName)
        self.assertEqual(s["n"].executionHash(c), IECore.MurmurHash())

        # now theres a file and object, we get some output
        s["sphere"] = GafferTest.SphereNode()
        s["n"]["in"].setInput(s["sphere"]["out"])
        self.assertNotEqual(s["n"].executionHash(c), IECore.MurmurHash())

        # output doesn't vary by time
        self.assertEqual(s["n"].executionHash(c), s["n"].executionHash(c2))

        # output varies by time since the file name does
        s["n"]["fileName"].setValue(self.__exrSequence.fileName)
        self.assertNotEqual(s["n"].executionHash(c), s["n"].executionHash(c2))
Пример #7
0
    def testLifetime(self):

        scriptNode = Gaffer.ScriptNode()
        scriptNode["write"] = Gaffer.ObjectWriter()
        scriptNode.selection().add(scriptNode["write"])

        for type in GafferUI.EditorWidget.types():
            editor = GafferUI.EditorWidget.create(type, scriptNode)
            w = weakref.ref(editor)
            del editor
            self.assertEqual(w(), None)

        self.assertEqual(w(), None)
Пример #8
0
    def testChangingFileType(self):

        checker = os.path.dirname(__file__) + "/images/checker.exr"
        checker = IECore.Reader.create(checker).read()

        node = Gaffer.ObjectWriter()
        node["fileName"].setValue(self.__exrFileName)
        node["in"].setValue(checker)

        node["fileName"].setValue(self.__tifFileName)

        node.execute([Gaffer.Context()])
        self.failUnless(os.path.exists(self.__tifFileName))

        self.failUnless(IECore.TIFFImageReader.canRead(self.__tifFileName))
Пример #9
0
    def testLifetime(self):

        application = Gaffer.Application("Layout tester")
        scriptNode = Gaffer.ScriptNode()
        application.root()["scripts"].addChild(scriptNode)

        scriptNode["write"] = Gaffer.ObjectWriter()
        scriptNode.selection().add(scriptNode["write"])

        for type in GafferUI.EditorWidget.types():
            editor = GafferUI.EditorWidget.create(type, scriptNode)
            w = weakref.ref(editor)
            del editor
            self.assertEqual(w(), None)

        self.assertEqual(w(), None)
Пример #10
0
    def testExtraneousPlugsAfterSerialisation(self):

        s = Gaffer.ScriptNode()
        s["n"] = Gaffer.ObjectWriter()
        s["n"]["fileName"].setValue(self.__exrFileName)

        self.failUnless("parameters" in s["n"])
        self.failIf("parameters1" in s["n"])

        ss = s.serialise()

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

        self.failUnless("parameters" in s["n"])
        self.failIf("parameters1" in s["n"])
Пример #11
0
	def testErrorReturnStatusForBadContext( self ) :
		
		s = Gaffer.ScriptNode()
		s["fileName"].setValue( self.__scriptFileName )
		s["write"] = Gaffer.ObjectWriter()
		s.save()
		
		p = subprocess.Popen(
			"gaffer execute -script " + self.__scriptFileName + " -context -myArg 10 -noValue",
			shell=True,
			stderr = subprocess.PIPE,
		)
		p.wait()
		
		error = "".join( p.stderr.readlines() )
		self.failUnless( "ERROR" in error )
		self.failUnless( "Context parameter" in error )
		self.failUnless( p.returncode )
Пример #12
0
    def testStringSubstitutions(self):

        checker = os.path.dirname(__file__) + "/images/checker.exr"
        checker = IECore.Reader.create(checker).read()

        node = Gaffer.ObjectWriter()
        node["fileName"].setValue(self.__exrSequence.fileName)
        node["in"].setValue(checker)

        contexts = []
        for i in self.__exrSequence.frameList.asList():
            context = Gaffer.Context()
            context.setFrame(i)
            with context:
                node.execute()

        for f in self.__exrSequence.fileNames():
            self.failUnless(os.path.exists(f))