def __printImage( self, script, args ) : import GafferImage import GafferImageTest image = script.descendant( args["image"].value ) if isinstance( image, Gaffer.Node ) : image = next( ( x for x in image.children( GafferImage.ImagePlug ) ), None ) if image is None : IECore.msg( IECore.Msg.Level.Error, "stats", "Image \"%s\" does not exist" % args["image"].value ) return memory = _Memory.maxRSS() with _Timer() as sceneTimer : with self.__performanceMonitor or _NullContextManager() : GafferImageTest.processTiles( image ) self.__timers["Image generation"] = sceneTimer self.__memory["Image generation"] = _Memory.maxRSS() - memory items = [ ( "Format", image["format"].getValue() ), ( "Data window", image["dataWindow"].getValue() ), ( "Channel names", image["channelNames"].getValue() ), ] print "\nImage :\n" self.__printItems( items )
def testCancellation(self):
c = GafferImage.Constant()
m = GafferImage.Median()
m["in"].setInput(c["out"])
m["radius"].setValue(imath.V2i(2000))
bt = Gaffer.ParallelAlgo.callOnBackgroundThread(
m["out"], lambda: GafferImageTest.processTiles(m["out"]))
# Give background tasks time to get into full swing
time.sleep(0.1)
# Check that we can cancel them in reasonable time
acceptableCancellationDelay = 0.25 if "TRAVIS" not in os.environ else 4.0
t = time.time()
bt.cancelAndWait()
self.assertLess(time.time() - t, acceptableCancellationDelay)
# Check that we can do the same when using a master
# channel.
m["masterChannel"].setValue("R")
bt = Gaffer.ParallelAlgo.callOnBackgroundThread(
m["out"], lambda: GafferImageTest.processTiles(m["out"]))
time.sleep(0.1)
t = time.time()
bt.cancelAndWait()
self.assertLess(time.time() - t, acceptableCancellationDelay)
def __writeImage( self, script, args ) : import GafferImage import GafferImageTest image = script.descendant( args["image"].value ) if isinstance( image, Gaffer.Node ) : image = next( ( x for x in image.children( GafferImage.ImagePlug ) ), None ) if image is None : IECore.msg( IECore.Msg.Level.Error, "stats", "Image \"%s\" does not exist" % args["image"].value ) return if args["preCache"].value : GafferImageTest.processTiles( image ) memory = _Memory.maxRSS() with _Timer() as imageTimer : with self.__performanceMonitor or _NullContextManager(), self.__contextMonitor or _NullContextManager() : with Gaffer.Context( script.context() ) as context : for frame in self.__frames( script, args ) : context.setFrame( frame ) GafferImageTest.processTiles( image ) self.__timers["Image generation"] = imageTimer self.__memory["Image generation"] = _Memory.maxRSS() - memory items = [ ( "Format", image["format"].getValue() ), ( "Data window", image["dataWindow"].getValue() ), ( "Channel names", image["channelNames"].getValue() ), ] self.__output.write( "\nImage :\n\n" ) self.__writeItems( items )
def __printImage(self, script, args):
import GafferImage
import GafferImageTest
image = script.descendant(args["image"].value)
if isinstance(image, Gaffer.Node):
image = next((x for x in image.children(GafferImage.ImagePlug)),
None)
if image is None:
IECore.msg(IECore.Msg.Level.Error, "stats",
"Image \"%s\" does not exist" % args["image"].value)
return
memory = _Memory.maxRSS()
with _Timer() as sceneTimer:
with self.__performanceMonitor or _NullContextManager():
GafferImageTest.processTiles(image)
self.__timers["Image generation"] = sceneTimer
self.__memory["Image generation"] = _Memory.maxRSS() - memory
self.__memory["OIIO cache limit"] = _Memory(
GafferImage.OpenImageIOReader.getCacheMemoryLimit())
self.__memory["OIIO cache usage"] = _Memory(
GafferImage.OpenImageIOReader.cacheMemoryUsage())
items = [
("Format", image["format"].getValue()),
("Data window", image["dataWindow"].getValue()),
("Channel names", image["channelNames"].getValue()),
]
print "\nImage :\n"
self.__printItems(items)
def testShaderNetworkGeneratedInGlobalContext( self ) : constant = GafferImage.Constant() outLayer = GafferOSL.OSLCode() outLayer["out"]["layer"] = GafferOSL.ClosurePlug( direction = Gaffer.Plug.Direction.Out, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) outLayer["code"].setValue( 'layer = outLayer( "", color( 0, 1, 0) )' ) outImage = GafferOSL.OSLShader() outImage.loadShader( "ImageProcessing/OutImage" ) outImage["parameters"]["in0"].setInput( outLayer["out"]["layer"] ) oslImage = GafferOSL.OSLImage() oslImage["in"].setInput( constant["out"] ) oslImage["shader"].setInput( outImage["out"] ) with Gaffer.ContextMonitor( outImage) as cm : GafferImageTest.processTiles( oslImage["out"] ) cs = cm.combinedStatistics() self.assertEqual( cs.numUniqueContexts(), 1 ) self.assertNotIn( "image:tileOrigin", cs.variableNames() ) self.assertNotIn( "image:channelName", cs.variableNames() )
def testCancellation( self ) : c = GafferImage.Constant() r = GafferImage.Resample() r["in"].setInput( c["out"] ) r["filterScale"].setValue( imath.V2f( 2000 ) ) bt = Gaffer.ParallelAlgo.callOnBackgroundThread( r["out"], lambda : GafferImageTest.processTiles( r["out"] ) ) # Give background tasks time to get into full swing time.sleep( 0.1 ) # Check that we can cancel them in reasonable time acceptableCancellationDelay = 0.25 if "TRAVIS" not in os.environ else 4.0 t = time.time() bt.cancelAndWait() self.assertLess( time.time() - t, acceptableCancellationDelay ) # Check that we can do the same when using a non-separable filter r["filter"].setValue( "disk" ) bt = Gaffer.ParallelAlgo.callOnBackgroundThread( r["out"], lambda : GafferImageTest.processTiles( r["out"] ) ) time.sleep( 0.1 ) t = time.time() bt.cancelAndWait() self.assertLess( time.time() - t, acceptableCancellationDelay )
def testCancellation(self):
c = GafferImage.Constant()
r = GafferImage.Resample()
r["in"].setInput(c["out"])
r["filterScale"].setValue(imath.V2f(2000))
bt = Gaffer.ParallelAlgo.callOnBackgroundThread(
r["out"], lambda: GafferImageTest.processTiles(r["out"]))
# Give background tasks time to get into full swing
time.sleep(0.1)
# Check that we can cancel them in reasonable time
acceptableCancellationDelay = 0.25 if "TRAVIS" not in os.environ else 4.0
t = time.time()
bt.cancelAndWait()
self.assertLess(time.time() - t, acceptableCancellationDelay)
# Check that we can do the same when using a non-separable filter
r["filter"].setValue("disk")
bt = Gaffer.ParallelAlgo.callOnBackgroundThread(
r["out"], lambda: GafferImageTest.processTiles(r["out"]))
time.sleep(0.1)
t = time.time()
bt.cancelAndWait()
self.assertLess(time.time() - t, acceptableCancellationDelay)
def testShaderNetworkGeneratedInGlobalContext(self):
constant = GafferImage.Constant()
outLayer = GafferOSL.OSLCode()
outLayer["out"]["layer"] = GafferOSL.ClosurePlug(
direction=Gaffer.Plug.Direction.Out,
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
outLayer["code"].setValue('layer = outLayer( "", color( 0, 1, 0) )')
outImage = GafferOSL.OSLShader()
outImage.loadShader("ImageProcessing/OutImage")
outImage["parameters"]["in0"].setInput(outLayer["out"]["layer"])
oslImage = GafferOSL.OSLImage()
oslImage["in"].setInput(constant["out"])
oslImage["shader"].setInput(outImage["out"]["out"])
with Gaffer.ContextMonitor(oslImage["__oslCode"]) as cm:
GafferImageTest.processTiles(oslImage["out"])
cs = cm.combinedStatistics()
self.assertEqual(cs.numUniqueContexts(), 1)
self.assertNotIn("image:tileOrigin", cs.variableNames())
self.assertNotIn("image:channelName", cs.variableNames())
def __writeImage( self, script, args ) : import GafferImage import GafferImageTest image = script.descendant( args["image"].value ) if isinstance( image, Gaffer.Node ) : image = next( ( x for x in image.children( GafferImage.ImagePlug ) ), None ) if image is None : IECore.msg( IECore.Msg.Level.Error, "stats", "Image \"%s\" does not exist" % args["image"].value ) return if args["preCache"].value : GafferImageTest.processTiles( image ) memory = _Memory.maxRSS() with _Timer() as imageTimer : with self.__performanceMonitor or _NullContextManager(), self.__contextMonitor or _NullContextManager() : GafferImageTest.processTiles( image ) self.__timers["Image generation"] = imageTimer self.__memory["Image generation"] = _Memory.maxRSS() - memory self.__memory["OIIO cache limit"] = _Memory( GafferImage.OpenImageIOReader.getCacheMemoryLimit() ) self.__memory["OIIO cache usage"] = _Memory( GafferImage.OpenImageIOReader.cacheMemoryUsage() ) items = [ ( "Format", image["format"].getValue() ), ( "Data window", image["dataWindow"].getValue() ), ( "Channel names", image["channelNames"].getValue() ), ] self.__output.write( "\nImage :\n\n" ) self.__writeItems( items )
def testParallelProcessEmptyDataWindow( self ) : d = GafferImage.Display() self.assertEqual( d["out"]["dataWindow"].getValue(), IECore.Box2i() ) GafferImageTest.processTiles( d["out"] ) d["out"].image() d["out"].imageHash()
def testParallelProcessEmptyDataWindow( self ) : d = GafferImage.Display() self.assertEqual( d["out"]["dataWindow"].getValue(), imath.Box2i() ) GafferImageTest.processTiles( d["out"] ) d["out"].image() d["out"].imageHash()
def testSamplerBoundsViolationCrash(self):
c = GafferImage.Constant()
c["format"].setValue(GafferImage.Format(3792, 3160))
r = GafferImage.Resize()
r["in"].setInput(c["out"])
r["format"].setValue(GafferImage.Format(1920, 1080))
r["fitMode"].setValue(r.FitMode.Vertical)
GafferImageTest.processTiles(r["out"])
def testSamplerBoundsViolationCrash( self ) : c = GafferImage.Constant() c["format"].setValue( GafferImage.Format( 3792, 3160 ) ) r = GafferImage.Resize() r["in"].setInput( c["out"] ) r["format"].setValue( GafferImage.Format( 1920, 1080 ) ) r["fitMode"].setValue( r.FitMode.Vertical ) GafferImageTest.processTiles( r["out"] )
def testUpsizingPerformance(self):
checker = GafferImage.Checkerboard()
checker["format"].setValue(GafferImage.Format(1000, 1000))
transform = GafferImage.ImageTransform()
transform["in"].setInput(checker["out"])
transform["transform"]["scale"].setValue(imath.V2f(3))
with GafferTest.TestRunner.PerformanceScope():
GafferImageTest.processTiles(transform["out"])
def testTranslationPerformance(self):
checker = GafferImage.Checkerboard()
checker["format"].setValue(GafferImage.Format(3000, 3000))
transform = GafferImage.ImageTransform()
transform["in"].setInput(checker["out"])
transform["transform"]["translate"].setValue(imath.V2f(2.2))
with GafferTest.TestRunner.PerformanceScope():
GafferImageTest.processTiles(transform["out"])
def testRotationAndScalingPerformance(self):
checker = GafferImage.Checkerboard()
checker["format"].setValue(GafferImage.Format(3000, 3000))
transform = GafferImage.ImageTransform()
transform["in"].setInput(checker["out"])
transform["transform"]["pivot"].setValue(imath.V2f(1500))
transform["transform"]["rotate"].setValue(2.5)
transform["transform"]["scale"].setValue(imath.V2f(0.75))
with GafferTest.TestRunner.PerformanceScope():
GafferImageTest.processTiles(transform["out"])
def testGILManagement(self):
# Make a network where a Catalogue
# is merged with an image that depends
# on a python expression.
s = Gaffer.ScriptNode()
s["catalogue"] = GafferImage.Catalogue()
s["constant"] = GafferImage.Constant()
s["expression"] = Gaffer.Expression()
s["expression"].setExpression(
'parent["constant"]["color"]["r"] = context["image:tileOrigin"].x')
s["merge"] = GafferImage.Merge()
s["merge"]["in"][0].setInput(s["catalogue"]["out"])
s["merge"]["in"][1].setInput(s["constant"]["out"])
# Arrange to generate the resulting image from C++
# threads whenever it is dirtied.
processTilesConnection = Gaffer.ScopedConnection(
GafferImageTest.connectProcessTilesToPlugDirtiedSignal(
s["merge"]["out"]))
# Send an image to the catalogue to demonstrate that
# we do not deadlock on the GIL.
r = GafferImage.ImageReader()
r["fileName"].setValue(
"${GAFFER_ROOT}/python/GafferImageTest/images/checker.exr")
self.sendImage(r["out"], s["catalogue"])
def testGILManagement( self ) :
# Make a network where a Catalogue
# is merged with an image that depends
# on a python expression.
s = Gaffer.ScriptNode()
s["catalogue"] = GafferImage.Catalogue()
s["constant"] = GafferImage.Constant()
s["expression"] = Gaffer.Expression()
s["expression"].setExpression( 'parent["constant"]["color"]["r"] = context["image:tileOrigin"].x' )
s["merge"] = GafferImage.Merge()
s["merge"]["in"][0].setInput( s["catalogue"]["out"] )
s["merge"]["in"][1].setInput( s["constant"]["out"] )
# Arrange to generate the resulting image from C++
# threads whenever it is dirtied.
processTilesConnection = Gaffer.ScopedConnection( GafferImageTest.connectProcessTilesToPlugDirtiedSignal( s["merge"]["out"] ) )
# Send an image to the catalogue to demonstrate that
# we do not deadlock on the GIL.
r = GafferImage.ImageReader()
r["fileName"].setValue( "${GAFFER_ROOT}/python/GafferImageTest/images/checker.exr" )
self.sendImage( r["out"], s["catalogue"] )
def testConcatenationPerformance1(self):
checker = GafferImage.Checkerboard()
checker["format"].setValue(GafferImage.Format(3000, 3000))
transform1 = GafferImage.ImageTransform("Transform1")
transform1["in"].setInput(checker["out"])
transform1["transform"]["pivot"].setValue(imath.V2f(1500))
transform1["transform"]["rotate"].setValue(2.5)
transform2 = GafferImage.ImageTransform("Transform2")
transform2["in"].setInput(transform1["out"])
transform2["transform"]["translate"].setValue(imath.V2f(10))
with GafferTest.TestRunner.PerformanceScope():
GafferImageTest.processTiles(transform2["out"])
def testDownsizingSamplerBounds( self ) : c = GafferImage.Constant() c["format"].setValue( GafferImage.Format( 50, 53 ) ) r = GafferImage.Resize() r["in"].setInput( c["out"] ) r["fitMode"].setValue( r.FitMode.Distort ) # Downsize to every single size smaller than the input, # to check for sampler bounds violations similar to those # which motivated the test above. for width in range( 1, 50 ) : for height in range( 1, 53 ) : r["format"].setValue( GafferImage.Format( width, height ) ) GafferImageTest.processTiles( r["out"] )
def testDownsizingSamplerBounds(self):
c = GafferImage.Constant()
c["format"].setValue(GafferImage.Format(50, 53))
r = GafferImage.Resize()
r["in"].setInput(c["out"])
r["fitMode"].setValue(r.FitMode.Distort)
# Downsize to every single size smaller than the input,
# to check for sampler bounds violations similar to those
# which motivated the test above.
for width in range(1, 50):
for height in range(1, 53):
r["format"].setValue(GafferImage.Format(width, height))
GafferImageTest.processTiles(r["out"])
def setUp( self ) : GafferTest.TestCase.setUp( self ) sanitiser = GafferImageTest.ContextSanitiser() sanitiser.__enter__() self.addCleanup( sanitiser.__exit__, None, None, None )
def testNegativeDataWindowOrigin( self ) : reader = GafferImage.ImageReader() reader["fileName"].setValue( os.path.dirname( __file__ ) + "/images/checker.exr" ) constant = GafferImage.Constant() constant["color"].setValue( imath.Color4f( 0.5, 0, 0, 1 ) ) offset = GafferImage.Offset() offset["in"].setInput( constant["out"] ) offset["offset"].setValue( imath.V2i( -200, -250 ) ) vectorWarp = GafferImage.VectorWarp() vectorWarp["in"].setInput( reader["out"] ) vectorWarp["vector"].setInput( offset["out"] ) GafferImageTest.processTiles( vectorWarp["out"] )
def testNegativeDataWindowOrigin( self ) : reader = GafferImage.ImageReader() reader["fileName"].setValue( os.path.dirname( __file__ ) + "/images/checker.exr" ) constant = GafferImage.Constant() constant["color"].setValue( IECore.Color4f( 0.5, 0, 0, 1 ) ) offset = GafferImage.Offset() offset["in"].setInput( constant["out"] ) offset["offset"].setValue( IECore.V2i( -200, -250 ) ) vectorWarp = GafferImage.VectorWarp() vectorWarp["in"].setInput( reader["out"] ) vectorWarp["vector"].setInput( offset["out"] ) GafferImageTest.processTiles( vectorWarp["out"] )
def testMonitorParallelProcessTiles(self):
numTilesX = 50
numTilesY = 50
c = GafferImage.Checkerboard()
c["format"].setValue(
GafferImage.Format(
numTilesX * GafferImage.ImagePlug.tileSize(),
numTilesY * GafferImage.ImagePlug.tileSize(),
))
with Gaffer.PerformanceMonitor() as m:
GafferImageTest.processTiles(c["out"])
self.assertEqual(
m.plugStatistics(c["out"]["channelData"]).computeCount,
numTilesX * numTilesY * 4)
def testCrashWithResizedInput(self):
b = GafferImage.Constant()
b["format"].setValue(GafferImage.Format(2048, 1556))
bResized = GafferImage.Resize()
bResized["in"].setInput(b["out"])
bResized["format"].setValue(GafferImage.Format(1920, 1080))
bResized["fitMode"].setValue(bResized.FitMode.Fit)
a = GafferImage.Constant()
a["format"].setValue(GafferImage.Format(1920, 1080))
merge = GafferImage.Merge()
merge["operation"].setValue(merge.Operation.Over)
merge["in"][0].setInput(bResized["out"])
merge["in"][1].setInput(a["out"])
GafferImageTest.processTiles(merge["out"])
def testCrashWithResizedInput( self ) : b = GafferImage.Constant() b["format"].setValue( GafferImage.Format( 2048, 1556 ) ) bResized = GafferImage.Resize() bResized["in"].setInput( b["out"] ) bResized["format"].setValue( GafferImage.Format( 1920, 1080 ) ) bResized["fitMode"].setValue( bResized.FitMode.Fit ) a = GafferImage.Constant() a["format"].setValue( GafferImage.Format( 1920, 1080 ) ) merge = GafferImage.Merge() merge["operation"].setValue( merge.Operation.Over ) merge["in"][0].setInput( bResized["out"] ) merge["in"][1].setInput( a["out"] ) GafferImageTest.processTiles( merge["out"] )
def mergePerf(self, operation, mismatch):
r = GafferImage.Checkerboard("Checkerboard")
r["format"].setValue(GafferImage.Format(4096, 3112, 1.000))
# Make the size of the checkerboard not a perfect multiple of tile size
# in case we ever fix Checkerboard to notice when tiles are repeated
# and return an identical hash ( which would invalidate this performance
# test )
r["size"].setValue(imath.V2f(64.01))
alphaShuffle = GafferImage.Shuffle()
alphaShuffle["in"].setInput(r["out"])
alphaShuffle["channels"].addChild(
GafferImage.Shuffle.ChannelPlug("A", "R"))
transform = GafferImage.Offset()
transform["in"].setInput(alphaShuffle["out"])
if mismatch:
transform["offset"].setValue(imath.V2i(4000, 3000))
else:
transform["offset"].setValue(imath.V2i(26, 42))
merge = GafferImage.Merge()
merge["operation"].setValue(operation)
merge["in"][0].setInput(alphaShuffle["out"])
merge["in"][1].setInput(transform["out"])
# Precache upstream network, we're only interested in the performance of Merge
GafferImageTest.processTiles(alphaShuffle["out"])
GafferImageTest.processTiles(transform["out"])
with GafferTest.TestRunner.PerformanceScope():
GafferImageTest.processTiles(merge["out"])
def testOIIOExrRead( self ) : # call through to c++ test. GafferImageTest.testOIIOExrRead()
def processer() : try : GafferImageTest.processTiles( g["out"] ) except Exception, e : exceptions.append( e )
def testEditableScopeForFormat( self ) : GafferImageTest.testEditableScopeForFormat()
def computeImage():
with self.__context(script, args) as context:
for frame in self.__frames(script, args):
context.setFrame(frame)
GafferImageTest.processTiles(image)
def computeImage() : with self.__context( script, args ) as context : for frame in self.__frames( script, args ) : context.setFrame( frame ) GafferImageTest.processTiles( image )
def runInteractive(self, useUI, useBlur, resolution):
script = Gaffer.ScriptNode()
script["Camera"] = GafferScene.Camera()
script["Camera"]["transform"]["translate"]["z"].setValue(6)
script["Sphere"] = GafferScene.Sphere("Sphere")
script["Sphere"]["radius"].setValue(10)
script["ImageShader"] = GafferArnold.ArnoldShader()
script["ImageShader"].loadShader("image")
script["ImageShader"]["parameters"]["filename"].setValue(
os.path.dirname(__file__) +
"/../GafferImageTest/images/GafferChecker.exr")
script["ImageShader"]["parameters"]["sscale"].setValue(16)
script["ImageShader"]["parameters"]["tscale"].setValue(16)
script["ShaderAssignment"] = GafferScene.ShaderAssignment()
script["ShaderAssignment"]["in"].setInput(script["Sphere"]["out"])
script["ShaderAssignment"]["shader"].setInput(
script["ImageShader"]["out"])
script["Group"] = GafferScene.Group()
script["Group"]["in"][0].setInput(script["Camera"]["out"])
script["Group"]["in"][1].setInput(script["ShaderAssignment"]["out"])
script["StandardOptions"] = GafferScene.StandardOptions()
script["StandardOptions"]["in"].setInput(script["Group"]["out"])
script["StandardOptions"]["options"]["renderCamera"]["value"].setValue(
'/group/camera')
script["StandardOptions"]["options"]["renderCamera"][
"enabled"].setValue(True)
script["StandardOptions"]["options"]["renderResolution"][
"value"].setValue(imath.V2i(resolution, resolution))
script["StandardOptions"]["options"]["renderResolution"][
"enabled"].setValue(True)
script["ArnoldOptions"] = GafferArnold.ArnoldOptions("ArnoldOptions")
script["ArnoldOptions"]["in"].setInput(
script["StandardOptions"]["out"])
# Make sure we leave some CPU available for Gaffer
script["ArnoldOptions"]["options"]["threads"]["value"].setValue(-1)
script["ArnoldOptions"]["options"]["threads"]["enabled"].setValue(True)
script["Outputs"] = GafferScene.Outputs()
script["Outputs"].addOutput(
"beauty",
IECoreScene.Output(
"Interactive/Beauty", "ieDisplay", "rgba", {
"quantize":
IECore.IntVectorData([0, 0, 0, 0]),
"driverType":
'ClientDisplayDriver',
"displayHost":
'localhost',
"displayPort":
str(GafferImage.Catalogue.displayDriverServer().portNumber(
)),
"remoteDisplayType":
'GafferImage::GafferDisplayDriver',
"filter":
'box',
}))
script["Outputs"]["in"].setInput(script["ArnoldOptions"]["out"])
script[
"InteractiveArnoldRender"] = GafferArnold.InteractiveArnoldRender(
)
script["InteractiveArnoldRender"]["in"].setInput(
script["Outputs"]["out"])
script["Catalogue"] = GafferImage.Catalogue("Catalogue")
script["Catalogue"]["directory"].setValue(self.temporaryDirectory() +
"/catalogues/test")
script["Blur"] = GafferImage.Blur("Blur")
script["Blur"]["in"].setInput(script["Catalogue"]["out"])
script["Blur"]["radius"]["x"].setValue(1.0)
script["Blur"]["radius"]["y"].setValue(1.0)
watchNode = script["Blur"] if useBlur else script["Catalogue"]
if useUI:
with GafferUI.Window() as window:
window.setFullScreen(True)
viewer = GafferUI.Viewer(script)
window.setVisible(True)
viewer.setNodeSet(Gaffer.StandardSet([watchNode]))
script['InteractiveArnoldRender']['state'].setValue(
GafferScene.InteractiveRender.State.Running)
self.waitForIdle(10)
viewer.view().viewportGadget().frame(
viewer.view().viewportGadget().getPrimaryChild().bound(),
imath.V3f(0, 0, 1))
frameCounter = {'i': 0}
def testFunc():
frameCounter['i'] += 1
script["Camera"]["transform"]["translate"]["x"].setValue(
math.sin(frameCounter['i'] * 0.1))
if frameCounter['i'] >= 50:
GafferUI.EventLoop.mainEventLoop().stop()
timer = QtCore.QTimer()
timer.setInterval(20)
timer.timeout.connect(testFunc)
GafferImageUI.ImageGadget.resetTileUpdateCount()
timer.start()
with GafferTest.TestRunner.PerformanceScope() as ps:
GafferUI.EventLoop.mainEventLoop().start()
ps.setNumIterations(
GafferImageUI.ImageGadget.tileUpdateCount())
script['InteractiveArnoldRender']['state'].setValue(
GafferScene.InteractiveRender.State.Stopped)
del window, viewer, timer
self.waitForIdle(10)
else:
with GafferTest.ParallelAlgoTest.UIThreadCallHandler() as h:
with IECore.CapturingMessageHandler() as mh:
script['InteractiveArnoldRender']['state'].setValue(
GafferScene.InteractiveRender.State.Running)
h.waitFor(2)
arnoldStartupErrors = mh.messages
tc = Gaffer.ScopedConnection(
GafferImageTest.connectProcessTilesToPlugDirtiedSignal(
watchNode["out"]))
with GafferTest.TestRunner.PerformanceScope() as ps:
with Gaffer.PerformanceMonitor() as m:
for i in range(250):
script["Camera"]["transform"]["translate"][
"x"].setValue(math.sin((i + 1) * 0.1))
h.waitFor(0.02)
ps.setNumIterations(
m.plugStatistics(
watchNode["out"]
["channelData"].source()).computeCount)
script['InteractiveArnoldRender']['state'].setValue(
GafferScene.InteractiveRender.State.Stopped)
def processer():
try:
GafferImageTest.processTiles(g["out"])
except Exception, e:
exceptions.append(e)
def testOIIOExrRead(self):
# call through to c++ test.
GafferImageTest.testOIIOExrRead()
