def testSetDriver( self ) :
semaphore = threading.Semaphore( 0 )
imageReceivedConnection = GafferImage.Display.imageReceivedSignal().connect( lambda plug : semaphore.release() )
driversCreated = GafferTest.CapturingSlot( GafferImage.Display.driverCreatedSignal() )
server = IECore.DisplayDriverServer()
cortexWindow = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 99 ) )
gafferWindow = IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 100 ) )
driver = IECore.ClientDisplayDriver(
cortexWindow,
cortexWindow,
[ "Y" ],
{
"displayHost" : "localHost",
"displayPort" : str( server.portNumber() ),
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
}
)
display = GafferImage.Display()
self.assertTrue( display.getDriver() is None )
self.assertTrue( len( driversCreated ), 1 )
display.setDriver( driversCreated[0][0] )
self.assertTrue( display.getDriver().isSame( driversCreated[0][0] ) )
self.__sendBucket( driver, cortexWindow, IECore.FloatVectorData( [ 0.5 ] * gafferWindow.size().x * gafferWindow.size().y ) )
self.assertEqual( display["out"]["format"].getValue().getDisplayWindow(), gafferWindow )
self.assertEqual( display["out"]["dataWindow"].getValue(), gafferWindow )
self.assertEqual( display["out"]["channelNames"].getValue(), IECore.StringVectorData( [ "Y" ] ) )
self.assertEqual(
display["out"].channelData( "Y", IECore.V2i( 0 ) ),
IECore.FloatVectorData( [ 0.5 ] * GafferImage.ImagePlug.tileSize() * GafferImage.ImagePlug.tileSize() )
)
display2 = GafferImage.Display()
display2.setDriver( display.getDriver(), copy = True )
self.assertImagesEqual( display["out"], display2["out"] )
self.__sendBucket( driver, cortexWindow, IECore.FloatVectorData( [ 1 ] * gafferWindow.size().x * gafferWindow.size().y ) )
self.assertEqual(
display["out"].channelData( "Y", IECore.V2i( 0 ) ),
IECore.FloatVectorData( [ 1 ] * GafferImage.ImagePlug.tileSize() * GafferImage.ImagePlug.tileSize() )
)
self.assertEqual(
display2["out"].channelData( "Y", IECore.V2i( 0 ) ),
IECore.FloatVectorData( [ 0.5 ] * GafferImage.ImagePlug.tileSize() * GafferImage.ImagePlug.tileSize() )
)
driver.imageClose()
semaphore.acquire()
def testSetDriver(self):
driversCreated = GafferTest.CapturingSlot(
GafferImage.Display.driverCreatedSignal())
server = IECoreImage.DisplayDriverServer()
dataWindow = IECore.Box2i(IECore.V2i(0), IECore.V2i(100))
driver = self.Driver(GafferImage.Format(dataWindow),
dataWindow, ["Y"],
port=server.portNumber())
self.assertTrue(len(driversCreated), 1)
display = GafferImage.Display()
self.assertTrue(display.getDriver() is None)
display.setDriver(driversCreated[0][0])
self.assertTrue(display.getDriver().isSame(driversCreated[0][0]))
driver.sendBucket(dataWindow, [
IECore.FloatVectorData(
[0.5] * dataWindow.size().x * dataWindow.size().y)
])
self.assertEqual(
display["out"]["format"].getValue().getDisplayWindow(), dataWindow)
self.assertEqual(display["out"]["dataWindow"].getValue(), dataWindow)
self.assertEqual(display["out"]["channelNames"].getValue(),
IECore.StringVectorData(["Y"]))
self.assertEqual(
display["out"].channelData("Y", IECore.V2i(0)),
IECore.FloatVectorData([0.5] * GafferImage.ImagePlug.tileSize() *
GafferImage.ImagePlug.tileSize()))
display2 = GafferImage.Display()
display2.setDriver(display.getDriver(), copy=True)
self.assertImagesEqual(display["out"], display2["out"])
driver.sendBucket(dataWindow, [
IECore.FloatVectorData(
[1] * dataWindow.size().x * dataWindow.size().y)
])
self.assertEqual(
display["out"].channelData("Y", IECore.V2i(0)),
IECore.FloatVectorData([1] * GafferImage.ImagePlug.tileSize() *
GafferImage.ImagePlug.tileSize()))
self.assertEqual(
display2["out"].channelData("Y", IECore.V2i(0)),
IECore.FloatVectorData([0.5] * GafferImage.ImagePlug.tileSize() *
GafferImage.ImagePlug.tileSize()))
driver.close()
def __testTransferImage(self, fileName):
imageReader = GafferImage.ImageReader()
imageReader["fileName"].setValue(os.path.expandvars(fileName))
imagesReceived = GafferTest.CapturingSlot(
GafferImage.Display.imageReceivedSignal())
node = GafferImage.Display()
server = IECoreImage.DisplayDriverServer()
driverCreatedConnection = GafferImage.Display.driverCreatedSignal(
).connect(lambda driver, parameters: node.setDriver(driver))
self.assertEqual(len(imagesReceived), 0)
self.Driver.sendImage(imageReader["out"], port=server.portNumber())
self.assertImagesEqual(imageReader["out"],
node["out"],
ignoreMetadata=True)
self.assertEqual(len(imagesReceived), 1)
self.assertEqual(imagesReceived[0][0], node["out"])
return node
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 testDefaultFormat( self ) : d = GafferImage.Display() with Gaffer.Context() as c : self.assertEqual( d["out"]["format"].getValue(), GafferImage.FormatPlug.getDefaultFormat( c ) ) GafferImage.FormatPlug.setDefaultFormat( c, GafferImage.Format( 200, 150, 1. ) ) self.assertEqual( d["out"]["format"].getValue(), GafferImage.FormatPlug.getDefaultFormat( c ) )
def testRenderingDuringScriptDeletion(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"].setInput(s["p"]["out"])
s["g"]["in1"].setInput(s["c"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"driverType": "ClientDisplayDriver",
"displayHost": "localhost",
"displayPort": "1559",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
"quantize": IECore.IntVectorData([0, 0, 0, 0]),
}))
s["d"]["in"].setInput(s["g"]["out"])
s["m"] = GafferImage.Display()
# connect a python function to the Display node image and data
# received signals. this emulates what the UI does.
def __displayCallback(plug):
pass
c = (
s["m"].imageReceivedSignal().connect(__displayCallback),
s["m"].dataReceivedSignal().connect(__displayCallback),
)
s["o"] = GafferScene.StandardOptions()
s["o"]["in"].setInput(s["d"]["out"])
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["options"]["renderCamera"]["value"].setValue("/group/plane")
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(1)
# delete the script while the render is still progressing. when
# this occurs, deletion of the render node will be triggered, which
# will in turn stop the render. this may flush data to the display,
# in which case it will emit its data and image received signals
# on a separate thread. if we're still holding the gil on the main
# thread when this happens, we'll get a deadlock.
del s
def testTileHashes( self ) :
semaphore = threading.Semaphore( 0 )
imageReceivedConnection = GafferImage.Display.imageReceivedSignal().connect( lambda plug : semaphore.release() )
node = GafferImage.Display()
node["port"].setValue( 2500 )
gafferDisplayWindow = IECore.Box2i( IECore.V2i( -100, -200 ), IECore.V2i( 303, 557 ) )
gafferFormat = GafferImage.Format( gafferDisplayWindow, 1.0 )
externalDisplayWindow = gafferFormat.toEXRSpace( gafferDisplayWindow )
externalDataWindow = externalDisplayWindow
gafferDataWindow = gafferDisplayWindow
driver = IECore.ClientDisplayDriver(
externalDisplayWindow,
externalDataWindow,
[ "Y" ],
{
"displayHost" : "localHost",
"displayPort" : "2500",
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
}
)
for i in range( 0, 1000 ) :
h1 = self.__tileHashes( node, "Y" )
t1 = self.__tiles( node, "Y" )
externalBucketWindow = IECore.Box2i()
for j in range( 0, 2 ) :
externalBucketWindow.extendBy(
IECore.V2i(
int( random.uniform( externalDisplayWindow.min.x, externalDisplayWindow.max.x ) ),
int( random.uniform( externalDisplayWindow.min.y, externalDisplayWindow.max.y ) ),
)
)
numPixels = ( externalBucketWindow.size().x + 1 ) * ( externalBucketWindow.size().y + 1 )
bucketData = IECore.FloatVectorData()
bucketData.resize( numPixels, i + 1 )
self.__sendBucket( driver, externalBucketWindow, bucketData )
h2 = self.__tileHashes( node, "Y" )
t2 = self.__tiles( node, "Y" )
gafferBucketWindow = gafferFormat.fromEXRSpace( externalBucketWindow )
self.__assertTilesChangedInRegion( t1, t2, gafferBucketWindow )
self.__assertTilesChangedInRegion( h1, h2, gafferBucketWindow )
driver.imageClose()
semaphore.acquire()
def testRenderingDuringScriptDeletion( self ) :
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue( 1 )
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput( s["p"]["out"] )
s["g"]["in"][1].setInput( s["c"]["out"] )
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test",
"ieDisplay",
"rgba",
{
"driverType" : "ClientDisplayDriver",
"displayHost" : "localhost",
"displayPort" : "1559",
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
"quantize" : IECore.IntVectorData( [ 0, 0, 0, 0 ] ),
}
)
)
s["d"]["in"].setInput( s["g"]["out"] )
# Emulate the connection the UI makes, so the Display knows someone is listening and
# it needs to actually make servers.
executeOnUIThreadConnection = GafferImage.Display.executeOnUIThreadSignal().connect( lambda f : f() )
s["m"] = GafferImage.Display()
s["o"] = GafferScene.StandardOptions()
s["o"]["in"].setInput( s["d"]["out"] )
s["o"]["options"]["renderCamera"]["enabled"].setValue( True )
s["o"]["options"]["renderCamera"]["value"].setValue( "/group/camera" )
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput( s["o"]["out"] )
s["r"]["state"].setValue( s["r"].State.Running )
time.sleep( 1 )
# delete the script while the render is still progressing. when
# this occurs, deletion of the render node will be triggered, which
# will in turn stop the render. this may flush data to the display,
# in which case it will emit its data and image received signals
# on a separate thread. if we're still holding the gil on the main
# thread when this happens, we'll get a deadlock.
del s
def __testTransferImage(self, fileName):
imageReader = GafferImage.ImageReader()
imageReader["fileName"].setValue(os.path.expandvars(fileName))
node = GafferImage.Display()
node["port"].setValue(2500)
driver = IECore.ClientDisplayDriver(
imageReader["out"]["format"].getValue().getDisplayWindow(),
imageReader["out"]["format"].getValue().formatToYDownSpace(
imageReader["out"]["dataWindow"].getValue()),
list(imageReader["out"]["channelNames"].getValue()), {
"displayHost": "localHost",
"displayPort": "2500",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
})
dataWindow = imageReader["out"]["dataWindow"].getValue()
tileSize = GafferImage.ImagePlug.tileSize()
minTileOrigin = GafferImage.ImagePlug.tileOrigin(dataWindow.min)
maxTileOrigin = GafferImage.ImagePlug.tileOrigin(dataWindow.max)
for y in range(minTileOrigin.y, maxTileOrigin.y + 1, tileSize):
for x in range(minTileOrigin.x, maxTileOrigin.x + 1, tileSize):
tileOrigin = IECore.V2i(x, y)
channelData = []
for channelName in imageReader["out"]["channelNames"].getValue(
):
channelData.append(imageReader["out"].channelData(
channelName, tileOrigin))
bucketData = IECore.FloatVectorData()
for by in range(tileSize - 1, -1, -1):
for bx in range(0, tileSize):
i = by * tileSize + bx
for c in channelData:
bucketData.append(c[i])
bucketBound = IECore.Box2i(
tileOrigin, tileOrigin +
IECore.V2i(GafferImage.ImagePlug.tileSize() - 1))
bucketBound = imageReader["out"]["format"].getValue(
).formatToYDownSpace(bucketBound)
driver.imageData(bucketBound, bucketData)
driver.imageClose()
self.__imageReceivedSemaphore.acquire()
# Display doesn't handle image metadata, so we must erase it before comparing the images
inImage = imageReader["out"].image()
inImage.blindData().clear()
self.assertEqual(inImage, node["out"].image())
return node
def testCommand( self ) :
s = Gaffer.ScriptNode()
s["sphere"] = GafferScene.Sphere()
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECore.Display(
"test",
"ieDisplay",
"rgba",
{
"quantize" : IECore.FloatVectorData( [ 0, 0, 0, 0 ] ),
"driverType" : "ClientDisplayDriver",
"displayHost" : "localhost",
"displayPort" : "1559",
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
"handle" : "myLovelyPlane",
}
)
)
s["outputs"]["in"].setInput( s["sphere"]["out"] )
s["display"] = GafferImage.Display()
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["ribFileName"].setValue( self.temporaryDirectory() + "/test.rib" )
s["render"]["in"].setInput( s["outputs"]["out"] )
s["fileName"].setValue( self.temporaryDirectory() + "/test.gfr" )
s.save()
# render a full frame and get the data window
s["render"]["task"].execute()
dataWindow1 = s["display"]["out"].image().dataWindow
# specify a crop on the command line and get the new data window
s["render"]["command"].setValue( "renderdl -crop 0 0.5 0 0.5" )
s["render"]["task"].execute()
# check that the crop worked
dataWindow2 = s["display"]["out"].image().dataWindow
self.assertEqual( dataWindow2.size(), dataWindow1.size() / 2 )
# now check that we can specify values via the context too
s["render"]["command"].setValue( "renderdl -crop 0 ${size} 0 ${size}" )
s.context()["size"] = 0.25
with s.context() :
s["render"]["task"].execute()
dataWindow3 = s["display"]["out"].image().dataWindow
self.assertEqual( dataWindow3.size(), dataWindow1.size() / 4 )
def testRenderToDisplayViaForegroundDispatch( self ) :
s = Gaffer.ScriptNode()
s["sphere"] = GafferScene.Sphere()
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECore.Display(
"test",
"ieDisplay",
"rgba",
{
"quantize" : IECore.FloatVectorData( [ 0, 0, 0, 0 ] ),
"driverType" : "ClientDisplayDriver",
"displayHost" : "localhost",
"displayPort" : "1559",
"remoteDisplayType" : "GafferImage::GafferDisplayDriver",
"handle" : "myLovelyPlane",
}
)
)
s["outputs"]["in"].setInput( s["sphere"]["out"] )
s["display"] = GafferImage.Display()
def __displayCallback( plug ) :
pass
# connect a python function to the Display node image and data
# received signals. this emulates what the UI does.
c = (
s["display"].imageReceivedSignal().connect( __displayCallback ),
s["display"].dataReceivedSignal().connect( __displayCallback ),
)
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["ribFileName"].setValue( self.temporaryDirectory() + "/test.rib" )
s["render"]["in"].setInput( s["outputs"]["out"] )
s["fileName"].setValue( self.temporaryDirectory() + "/test.gfr" )
s.save()
# dispatch the render on the foreground thread. if we don't manage
# the GIL appropriately, we'll get a deadlock when the Display signals
# above try to enter python on the background thread.
dispatcher = GafferDispatch.LocalDispatcher()
dispatcher["jobsDirectory"].setValue( self.temporaryDirectory() + "/testJobDirectory" )
dispatcher["framesMode"].setValue( GafferDispatch.Dispatcher.FramesMode.CurrentFrame )
dispatcher["executeInBackground"].setValue( False )
dispatcher.dispatch( [ s["render"] ] )
def testNoErrorOnBackgroundDispatch( self ) : s = Gaffer.ScriptNode() s["d"] = GafferImage.Display() s["p"] = GafferDispatch.PythonCommand() s["p"]["command"].setValue( "pass" ) s["fileName"].setValue( self.temporaryDirectory() + "test.gfr" ) s.save() output = subprocess.check_output( [ "gaffer", "execute", self.temporaryDirectory() + "test.gfr", "-nodes", "p" ], stderr = subprocess.STDOUT ) self.assertEqual( output, "" )
def testTileHashes(self):
node = GafferImage.Display()
node["port"].setValue(2500)
displayWindow = IECore.Box2i(IECore.V2i(-100, -200),
IECore.V2i(302, 556))
dataWindow = displayWindow
driver = IECore.ClientDisplayDriver(
displayWindow, dataWindow, ["Y"], {
"displayHost": "localHost",
"displayPort": "2500",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
})
for i in range(0, 1000):
h1 = self.__tileHashes(node, "Y")
t1 = self.__tiles(node, "Y")
bucketWindow = IECore.Box2i()
for j in range(0, 2):
bucketWindow.extendBy(
IECore.V2i(
int(
random.uniform(displayWindow.min.x,
displayWindow.max.x)),
int(
random.uniform(displayWindow.min.y,
displayWindow.max.y)),
))
numPixels = (bucketWindow.size().x + 1) * (bucketWindow.size().y +
1)
bucketData = IECore.FloatVectorData()
bucketData.resize(numPixels, i + 1)
driver.imageData(bucketWindow, bucketData)
self.__dataReceivedSemaphore.acquire()
h2 = self.__tileHashes(node, "Y")
t2 = self.__tiles(node, "Y")
bucketWindowYUp = GafferImage.Format(
displayWindow, 1).yDownToFormatSpace(bucketWindow)
self.__assertTilesChangedInRegion(t1, t2, bucketWindowYUp)
self.__assertTilesChangedInRegion(h1, h2, bucketWindowYUp)
driver.imageClose()
def testDefaultFormat(self):
s = Gaffer.ScriptNode()
d = GafferImage.Display()
s.addChild(d)
p = GafferImage.ImagePlug("in", Gaffer.Plug.Direction.In)
p.setInput(d["out"])
with s.context():
self.assertEqual(p["format"].getValue(),
GafferImage.Format.getDefaultFormat(s))
GafferImage.Format.setDefaultFormat(
s, GafferImage.Format(200, 150, 1.))
self.assertEqual(p["format"].getValue(),
GafferImage.Format.getDefaultFormat(s))
def __testTransferImage(self, fileName):
imageReader = GafferImage.ImageReader()
imageReader["fileName"].setValue(os.path.expandvars(fileName))
node = GafferImage.Display()
node["port"].setValue(2500)
self.sendImage(imageReader["out"], port=2500)
# Display doesn't handle image metadata, so we must erase it before comparing the images
inImage = imageReader["out"].image()
inImage.blindData().clear()
self.assertEqual(inImage, node["out"].image())
return node
def testTileHashes(self):
node = GafferImage.Display()
server = IECoreImage.DisplayDriverServer()
driverCreatedConnection = GafferImage.Display.driverCreatedSignal(
).connect(lambda driver, parameters: node.setDriver(driver))
dataWindow = imath.Box2i(imath.V2i(-100, -200), imath.V2i(303, 557))
driver = self.Driver(
GafferImage.Format(dataWindow),
dataWindow,
["Y"],
port=server.portNumber(),
)
for i in range(0, 100):
h1 = self.__tileHashes(node, "Y")
t1 = self.__tiles(node, "Y")
bucketWindow = imath.Box2i()
while GafferImage.BufferAlgo.empty(bucketWindow):
bucketWindow.extendBy(
imath.V2i(
int(
random.uniform(dataWindow.min().x,
dataWindow.max().x)),
int(
random.uniform(dataWindow.min().y,
dataWindow.max().y)),
))
numPixels = (bucketWindow.size().x + 1) * (bucketWindow.size().y +
1)
bucketData = IECore.FloatVectorData()
bucketData.resize(numPixels, i + 1)
driver.sendBucket(bucketWindow, [bucketData])
h2 = self.__tileHashes(node, "Y")
t2 = self.__tiles(node, "Y")
self.__assertTilesChangedInRegion(t1, t2, bucketWindow)
self.__assertTilesChangedInRegion(h1, h2, bucketWindow)
driver.close()
def testCacheReuse(self):
# Send an image to the catalogue, and also
# capture the display driver that we used to
# send it.
c = GafferImage.Catalogue()
c["directory"].setValue(
os.path.join(self.temporaryDirectory(), "catalogue"))
drivers = GafferTest.CapturingSlot(
GafferImage.Display.driverCreatedSignal())
r = GafferImage.ImageReader()
r["fileName"].setValue(
"${GAFFER_ROOT}/python/GafferImageTest/images/checker.exr")
self.sendImage(r["out"], c)
self.assertEqual(len(drivers), 1)
# The image will have been saved to disk so it can persist between sessions,
# and the Catalogue should have dropped any reference it has to the driver,
# in order to save memory.
self.assertEqual(len(c["images"]), 1)
self.assertEqual(
os.path.dirname(c["images"][0]["fileName"].getValue()),
c["directory"].getValue())
self.assertEqual(drivers[0][0].refCount(), 1)
# But we don't want the Catalogue to immediately reload the image from
# disk, because for large images with many AOVs this is a huge overhead.
# We want to temporarily reuse the cache entries that were created from
# the data in the display driver. These should be identical to a regular
# Display node containing the same driver.
display = GafferImage.Display()
display.setDriver(drivers[0][0])
self.assertEqual(display["out"].channelDataHash("R", imath.V2i(0)),
c["out"].channelDataHash("R", imath.V2i(0)))
self.assertTrue(display["out"].channelData(
"R", imath.V2i(0),
_copy=False).isSame(c["out"].channelData("R",
imath.V2i(0),
_copy=False)))
# This applies to copies too
c["images"].addChild(
GafferImage.Catalogue.Image(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic))
self.assertEqual(len(c["images"]), 2)
c["images"][1].copyFrom(c["images"][0])
c["imageIndex"].setValue(1)
self.assertEqual(display["out"].channelDataHash("R", imath.V2i(0)),
c["out"].channelDataHash("R", imath.V2i(0)))
self.assertTrue(display["out"].channelData(
"R", imath.V2i(0),
_copy=False).isSame(c["out"].channelData("R",
imath.V2i(0),
_copy=False)))
def testEditSubdivisionAttributes(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["cube"]["dimensions"].setValue(IECore.V3f(2))
script["meshType"] = GafferScene.MeshType()
script["meshType"]["in"].setInput(script["cube"]["out"])
script["meshType"]["meshType"].setValue("catmullClark")
script["attributes"] = GafferArnold.ArnoldAttributes()
script["attributes"]["in"].setInput(script["meshType"]["out"])
script["attributes"]["attributes"]["subdivIterations"][
"enabled"].setValue(True)
script["outputs"] = GafferScene.Outputs()
script["outputs"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"driverType": "ClientDisplayDriver",
"displayType": "IECore::ClientDisplayDriver",
"displayHost": "localhost",
"displayPort": "2500",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
}))
script["outputs"]["in"].setInput(script["attributes"]["out"])
script["display"] = GafferImage.Display()
script["display"]["port"].setValue(2500)
script["imageStats"] = GafferImage.ImageStats()
script["imageStats"]["in"].setInput(script["display"]["out"])
script["imageStats"]["channels"].setValue(
IECore.StringVectorData(["R", "G", "B", "A"]))
script["imageStats"]["regionOfInterest"].setValue(
IECore.Box2i(IECore.V2i(0), IECore.V2i(640, 480)))
script["render"] = self._createInteractiveRender()
script["render"]["in"].setInput(script["outputs"]["out"])
# Render the cube with one level of subdivision. Check we get roughly the
# alpha coverage we expect.
script["render"]["state"].setValue(script["render"].State.Running)
time.sleep(1)
self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(),
0.381,
delta=0.001)
# Now up the number of subdivision levels. The alpha coverage should
# increase as the shape tends towards the limit surface.
script["attributes"]["attributes"]["subdivIterations"][
"value"].setValue(4)
time.sleep(1)
self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(),
0.424,
delta=0.001)
def testSetDriver(self):
driversCreated = GafferTest.CapturingSlot(
GafferImage.Display.driverCreatedSignal())
server = IECoreImage.DisplayDriverServer()
dataWindow = imath.Box2i(imath.V2i(0),
imath.V2i(GafferImage.ImagePlug.tileSize()))
driver = self.Driver(GafferImage.Format(dataWindow),
dataWindow, ["Y"],
port=server.portNumber())
try:
self.assertTrue(len(driversCreated), 1)
display = GafferImage.Display()
self.assertTrue(display.getDriver() is None)
dirtiedPlugs = GafferTest.CapturingSlot(
display.plugDirtiedSignal())
display.setDriver(driversCreated[0][0])
self.assertTrue(display.getDriver().isSame(driversCreated[0][0]))
# Ensure all the output plugs have been dirtied
expectedDirty = {"__driverCount", "__channelDataCount",
"out"}.union({
c.getName()
for c in display["out"].children()
})
self.assertEqual(expectedDirty,
set(e[0].getName() for e in dirtiedPlugs))
del dirtiedPlugs[:]
driver.sendBucket(dataWindow, [
IECore.FloatVectorData(
[0.5] * dataWindow.size().x * dataWindow.size().y)
])
self.assertEqual(
display["out"]["format"].getValue().getDisplayWindow(),
dataWindow)
self.assertEqual(display["out"]["dataWindow"].getValue(),
dataWindow)
self.assertEqual(display["out"]["channelNames"].getValue(),
IECore.StringVectorData(["Y"]))
self.assertEqual(
display["out"].channelData("Y", imath.V2i(0)),
IECore.FloatVectorData([0.5] *
GafferImage.ImagePlug.tileSize() *
GafferImage.ImagePlug.tileSize()))
# Ensure only channel data has been dirtied
expectedDirty = {"channelData", "__channelDataCount", "out"}
self.assertEqual(set(e[0].getName() for e in dirtiedPlugs),
expectedDirty)
display2 = GafferImage.Display()
display2.setDriver(display.getDriver(), copy=True)
self.assertImagesEqual(display["out"], display2["out"])
driver.sendBucket(dataWindow, [
IECore.FloatVectorData(
[1] * dataWindow.size().x * dataWindow.size().y)
])
self.assertEqual(
display["out"].channelData("Y", imath.V2i(0)),
IECore.FloatVectorData([1] * GafferImage.ImagePlug.tileSize() *
GafferImage.ImagePlug.tileSize()))
self.assertEqual(
display2["out"].channelData("Y", imath.V2i(0)),
IECore.FloatVectorData([0.5] *
GafferImage.ImagePlug.tileSize() *
GafferImage.ImagePlug.tileSize()))
finally:
driver.close()
def testDeep(self):
d = GafferImage.Display()
self.assertEqual(d["out"]["deep"].getValue(), False)
