def testPixelAspectRatio( self ) : r = GafferImage.ImageReader() r["fileName"].setValue( self.__rgbFilePath+".exr" ) self.assertEqual( r["out"]["format"].getValue().getPixelAspect(), 1 ) self.assertEqual( r["out"]["metadata"].getValue()["PixelAspectRatio"], IECore.FloatData( 1 ) ) # change the Format pixel aspect f = GafferImage.Resize() f["in"].setInput( r["out"] ) f["format"].setValue( GafferImage.Format( r["out"]["format"].getValue().getDisplayWindow(), 2. ) ) self.assertEqual( f["out"]["format"].getValue().getPixelAspect(), 2 ) # processing does not change metadata self.assertEqual( r["out"]["metadata"].getValue()["PixelAspectRatio"], IECore.FloatData( 1 ) ) testFile = self.__testFile( "pixelAspectFromFormat", "RGBA", "exr" ) self.failIf( os.path.exists( testFile ) ) w = GafferImage.ImageWriter() w["in"].setInput( f["out"] ) w["fileName"].setValue( testFile ) w["channels"].setValue( IECore.StringVectorData( f["out"]["channelNames"].getValue() ) ) with Gaffer.Context() : w.execute() self.failUnless( os.path.exists( testFile ) ) after = GafferImage.ImageReader() after["fileName"].setValue( testFile ) # the image is loaded with the correct pixel aspect self.assertEqual( after["out"]["format"].getValue().getPixelAspect(), 2 ) # the metadata reflects this as well self.assertEqual( after["out"]["metadata"].getValue()["PixelAspectRatio"], IECore.FloatData( 2 ) )
def testDefaultFormatWrite(self):
s = Gaffer.ScriptNode()
w = GafferImage.ImageWriter()
g = GafferImage.Grade()
s.addChild(g)
s.addChild(w)
testFile = self.__testFilePath + "testBlack.exr"
self.failIf(os.path.exists(testFile))
GafferImage.Format.setDefaultFormat(
s,
GafferImage.Format(
IECore.Box2i(IECore.V2i(-7, -2), IECore.V2i(22, 24)), 1.))
w["in"].setInput(g["out"])
w["fileName"].setValue(testFile)
w["channels"].setValue(
IECore.StringVectorData(g["out"]["channelNames"].getValue()))
# Try to execute. In older versions of the ImageWriter this would throw an exception.
with s.context():
w.execute()
self.failUnless(os.path.exists(testFile))
# Check the output.
expectedFile = self.__defaultFormatFile
expectedOutput = IECore.Reader.create(expectedFile).read()
expectedOutput.blindData().clear()
writerOutput = IECore.Reader.create(testFile).read()
writerOutput.blindData().clear()
self.assertEqual(writerOutput, expectedOutput)
def testWriteEmptyImage( self ) : i = GafferImage.Constant() i["format"].setValue( GafferImage.Format( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 100 ) ), 1 ) ) c = GafferImage.Crop() c["areaSource"].setValue( GafferImage.Crop.AreaSource.Area ) c["area"].setValue( IECore.Box2i( IECore.V2i( 40 ), IECore.V2i( 40 ) ) ) c["affectDisplayWindow"].setValue( False ) c["affectDataWindow"].setValue( True ) c["in"].setInput( i["out"] ) testFile = self.__testFile( "emptyImage", "RGBA", "exr" ) self.failIf( os.path.exists( testFile ) ) w = GafferImage.ImageWriter() w["in"].setInput( c["out"] ) w["fileName"].setValue( testFile ) with Gaffer.Context(): w.execute() self.failUnless( os.path.exists( testFile ) ) after = GafferImage.ImageReader() after["fileName"].setValue( testFile ) # Check that the data window and the display window are the same self.assertEqual( after["out"]["format"].getValue().getDisplayWindow(), after["out"]["dataWindow"].getValue() )
def testLargeDataWindowAddedToSmall(self):
b = GafferImage.Constant()
b["format"].setValue(GafferImage.Format(500, 500, 1.0))
b["color"].setValue(imath.Color4f(1, 0, 0, 1))
a = GafferImage.Constant()
a["format"].setValue(GafferImage.Format(500, 500, 1.0))
a["color"].setValue(imath.Color4f(0, 1, 0, 1))
mask = GafferImage.Constant()
mask["format"].setValue(GafferImage.Format(500, 500, 1.0))
mask["color"].setValue(imath.Color4f(0.5))
bCrop = GafferImage.Crop()
bCrop["in"].setInput(b["out"])
bCrop["areaSource"].setValue(bCrop.AreaSource.Area)
bCrop["area"].setValue(imath.Box2i(imath.V2i(50), imath.V2i(162)))
bCrop["affectDisplayWindow"].setValue(False)
m = GafferImage.Mix()
m["in"][0].setInput(bCrop["out"])
m["in"][1].setInput(a["out"])
m["mask"].setInput(mask["out"])
redSampler = GafferImage.Sampler(
m["out"], "R", m["out"]["format"].getValue().getDisplayWindow())
greenSampler = GafferImage.Sampler(
m["out"], "G", m["out"]["format"].getValue().getDisplayWindow())
blueSampler = GafferImage.Sampler(
m["out"], "B", m["out"]["format"].getValue().getDisplayWindow())
def sample(x, y):
return imath.Color3f(
redSampler.sample(x, y),
greenSampler.sample(x, y),
blueSampler.sample(x, y),
)
# We should only have yellow in areas where the background exists,
# and should have just green everywhere else.
self.assertEqual(sample(49, 49), imath.Color3f(0, 0.5, 0))
self.assertEqual(sample(50, 50), imath.Color3f(0.5, 0.5, 0))
self.assertEqual(sample(161, 161), imath.Color3f(0.5, 0.5, 0))
self.assertEqual(sample(162, 162), imath.Color3f(0, 0.5, 0))
def testSampleOffsets( self ) : ts = GafferImage.ImagePlug.tileSize() e = GafferImage.Empty() e["format"].setValue( GafferImage.Format( 2048, 1156, 1. ) ) self.assertEqual( e["out"].sampleOffsets( imath.V2i( 0 ) ), IECore.IntVectorData( [ 0 ] * ts * ts ) )
def testOffsetDisplayWindow( self ) : box = IECore.Box2i( IECore.V2i( 6, -4 ), IECore.V2i( 49, 149 ) ) f = GafferImage.Format( box, 1.1 ) self.assertEqual( f.getDisplayWindow(), box ) self.assertEqual( f.width(), 44 ) self.assertEqual( f.height(), 154 ) self.assertEqual( f.getPixelAspect(), 1.1 )
def testAutoConstructFromFormat(self):
f = GafferImage.Format(
IECore.Box2i(IECore.V2i(0), IECore.V2i(200, 100)), 0.5)
d = IECore.CompoundData()
d["f"] = f
self.assertEqual(d["f"], GafferImage.FormatData(f))
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 __constantLayer( self, layer, color, size = IECore.V2i( 512 ) ) : result = GafferImage.Constant() result["format"].setValue( GafferImage.Format( IECore.Box2i( IECore.V2i( 0 ), size ), 1 ) ) result["color"].setValue( color ) result["layer"].setValue( layer ) return result
def testDefaultFormatForImage(self):
constant = GafferImage.Constant()
with Gaffer.Context() as c:
GafferImage.FormatPlug.setDefaultFormat(
c, GafferImage.Format(100, 200))
self.assertEqual(
GafferImage.ImageAlgo.image(constant["out"]).displayWindow,
imath.Box2i(imath.V2i(0), imath.V2i(99, 199)))
GafferImage.FormatPlug.setDefaultFormat(
c, GafferImage.Format(200, 300))
self.assertEqual(
GafferImage.ImageAlgo.image(constant["out"]).displayWindow,
imath.Box2i(imath.V2i(0), imath.V2i(199, 299)))
def testEmptyBoxCoordinateSystemTransforms(self):
f = GafferImage.Format(100, 200)
self.assertEqual(f.toEXRSpace(IECore.Box2i()), IECore.Box2i())
self.assertEqual(
f.toEXRSpace(IECore.Box2i(IECore.V2i(0), IECore.V2i(0))),
IECore.Box2i())
self.assertEqual(f.fromEXRSpace(IECore.Box2i()), IECore.Box2i())
def testOffsetDisplayWindow(self):
box = imath.Box2i(imath.V2i(6, -4), imath.V2i(50, 150))
f = GafferImage.Format(box, 1.1)
self.assertEqual(f.getDisplayWindow(), box)
self.assertEqual(f.width(), 44)
self.assertEqual(f.height(), 154)
self.assertEqual(f.getPixelAspect(), 1.1)
def testSmallDataWindowOverLarge( self ) : b = GafferImage.Constant() b["format"].setValue( GafferImage.Format( 500, 500, 1.0 ) ) b["color"].setValue( IECore.Color4f( 1, 0, 0, 1 ) ) a = GafferImage.Constant() a["format"].setValue( GafferImage.Format( 500, 500, 1.0 ) ) a["color"].setValue( IECore.Color4f( 0, 1, 0, 1 ) ) mask = GafferImage.Constant() mask["format"].setValue( GafferImage.Format( 500, 500, 1.0 ) ) mask["color"].setValue( IECore.Color4f( 0.75 ) ) aCrop = GafferImage.Crop() aCrop["in"].setInput( a["out"] ) aCrop["areaSource"].setValue( aCrop.AreaSource.Area ) aCrop["area"].setValue( IECore.Box2i( IECore.V2i( 50 ), IECore.V2i( 162 ) ) ) aCrop["affectDisplayWindow"].setValue( False ) m = GafferImage.Mix() m["in"][0].setInput( b["out"] ) m["in"][1].setInput( aCrop["out"] ) m["mask"].setInput( mask["out"] ) redSampler = GafferImage.Sampler( m["out"], "R", m["out"]["format"].getValue().getDisplayWindow() ) greenSampler = GafferImage.Sampler( m["out"], "G", m["out"]["format"].getValue().getDisplayWindow() ) blueSampler = GafferImage.Sampler( m["out"], "B", m["out"]["format"].getValue().getDisplayWindow() ) def sample( x, y ) : return IECore.Color3f( redSampler.sample( x, y ), greenSampler.sample( x, y ), blueSampler.sample( x, y ), ) # We should only have green in areas which are inside # the data window of aCrop. But we still only take 25% # of the red everywhere self.assertEqual( sample( 49, 49 ), IECore.Color3f( 0.25, 0, 0 ) ) self.assertEqual( sample( 50, 50 ), IECore.Color3f( 0.25, 0.75, 0 ) ) self.assertEqual( sample( 161, 161 ), IECore.Color3f( 0.25, 0.75, 0 ) ) self.assertEqual( sample( 162, 162 ), IECore.Color3f( 0.25, 0, 0 ) )
def testConstructor(self):
p = GafferImage.FormatPlug()
self.assertEqual(p.getName(), "FormatPlug")
self.assertEqual(p.direction(), Gaffer.Plug.Direction.In)
self.assertEqual(p.defaultValue(), GafferImage.Format())
self.assertEqual(p.getValue(), GafferImage.Format())
self.assertEqual(p.getFlags(), Gaffer.Plug.Flags.Default)
p = GafferImage.FormatPlug(
"p", Gaffer.Plug.Direction.Out, GafferImage.Format(100, 200, 2),
Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
self.assertEqual(p.getName(), "p")
self.assertEqual(p.direction(), Gaffer.Plug.Direction.Out)
self.assertEqual(p.defaultValue(), GafferImage.Format(100, 200, 2))
self.assertEqual(p.getValue(), GafferImage.Format(100, 200, 2))
self.assertEqual(p.getFlags(),
Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
def testChannelNamesPassThrough( self ) : c = GafferImage.Constant() r = GafferImage.Reformat() r["in"].setInput( c["out"] ) r["format"].setValue( GafferImage.Format( 200, 150, 1.0 ) ) self.assertEqual( r["out"]["channelNames"].hash(), c["out"]["channelNames"].hash() ) self.assertEqual( r["out"]["channelNames"].getValue(), c["out"]["channelNames"].getValue() )
def testValue( self ) : p = GafferImage.FormatPlug() v = GafferImage.Format( imath.Box2i( imath.V2i( 11, 12 ), imath.V2i( 100, 200 ) ), 2 ) p.setValue( v ) self.assertEqual( p.getValue(), v ) self.assertEqual( p["displayWindow"].getValue(), v.getDisplayWindow() ) self.assertEqual( p["pixelAspect"].getValue(), v.getPixelAspect() )
def testDefaultFormatHashRepeatability( self ) : allHashes = set() for i in range( 0, 1000 ) : c = Gaffer.Context() GafferImage.FormatPlug.setDefaultFormat( c, GafferImage.Format( 1920, 1080 ) ) allHashes.add( str( c.hash() ) ) self.assertEqual( len( allHashes ), 1 )
def testTileHashes(self):
# Test that two tiles within the image have the same hash.
c = GafferImage.Constant()
c["format"].setValue(GafferImage.Format(2048, 1156, 1.))
c["color"][0].setValue(.5)
h1 = c["out"].channelData("R", IECore.V2i(0)).hash()
h2 = c["out"].channelData(
"R", IECore.V2i(GafferImage.ImagePlug().tileSize())).hash()
self.assertEqual(h1, h2)
def testDefaultColorSpaceFunctionArguments(self):
# Make a network to write and read an image
# in various formats.
c = GafferImage.Constant()
c["format"].setValue(GafferImage.Format(64, 64))
w = GafferImage.ImageWriter()
w["in"].setInput(c["out"])
r = GafferImage.ImageReader()
r["fileName"].setInput(w["fileName"])
# Register a custom colorspace function that
# just captures its arguments.
capturedArguments = {}
def f(fileName, fileFormat, dataType, metadata):
capturedArguments.update({
"fileName": fileName,
"fileFormat": fileFormat,
"dataType": dataType,
"metadata": metadata,
})
return "linear"
GafferImage.ImageReader.setDefaultColorSpaceFunction(f)
# Verify that the correct arguments are passed for
# a variety of fileNames and dataTypes.
for ext, fileFormat, dataType in [
("exr", "openexr", "half"),
("dpx", "dpx", "uint12"),
("TIFF", "tiff", "float"),
("tif", "tiff", "uint32"),
]:
w["fileName"].setValue("{0}/{1}.{2}".format(
self.temporaryDirectory(), dataType, ext))
w[fileFormat]["dataType"].setValue(dataType)
w.execute()
capturedArguments.clear()
r["out"].channelData(
"R", imath.V2i(0)) # Triggers call to color space function
self.assertEqual(len(capturedArguments), 4)
self.assertEqual(capturedArguments["fileName"],
w["fileName"].getValue())
self.assertEqual(capturedArguments["fileFormat"], fileFormat)
self.assertEqual(capturedArguments["dataType"], dataType)
self.assertEqual(capturedArguments["metadata"],
r["out"]["metadata"].getValue())
def testEmptyDataWindow(self):
e = self.emptyImage()
r = GafferImage.Resize()
r["in"].setInput(e["out"])
r["format"].setValue(GafferImage.Format(2121, 1012))
self.assertEqual(r["out"]["dataWindow"].getValue(), imath.Box2i())
def testDataWindowWhenBNotConnected( self ) : a = GafferImage.Constant() a["format"].setValue( GafferImage.Format( 100, 200 ) ) m = GafferImage.Merge() m["in"][1].setInput( a["out"] ) self.assertEqual( m["out"]["dataWindow"].getValue(), a["out"]["dataWindow"].getValue() )
def testSmallDataWindowOverLarge(self):
b = GafferImage.Constant()
b["format"].setValue(GafferImage.Format(500, 500, 1.0))
b["color"].setValue(imath.Color4f(1, 0, 0, 1))
a = GafferImage.Constant()
a["format"].setValue(GafferImage.Format(500, 500, 1.0))
a["color"].setValue(imath.Color4f(0, 1, 0, 1))
aCrop = GafferImage.Crop()
aCrop["in"].setInput(a["out"])
aCrop["areaSource"].setValue(aCrop.AreaSource.Area)
aCrop["area"].setValue(imath.Box2i(imath.V2i(50), imath.V2i(162)))
aCrop["affectDisplayWindow"].setValue(False)
m = GafferImage.Merge()
m["operation"].setValue(m.Operation.Over)
m["in"][0].setInput(b["out"])
m["in"][1].setInput(aCrop["out"])
redSampler = GafferImage.Sampler(
m["out"], "R", m["out"]["format"].getValue().getDisplayWindow())
greenSampler = GafferImage.Sampler(
m["out"], "G", m["out"]["format"].getValue().getDisplayWindow())
blueSampler = GafferImage.Sampler(
m["out"], "B", m["out"]["format"].getValue().getDisplayWindow())
def sample(x, y):
return imath.Color3f(
redSampler.sample(x, y),
greenSampler.sample(x, y),
blueSampler.sample(x, y),
)
# We should only have overed green in areas which are inside
# the data window of aCrop. Everywhere else we should have
# red still.
self.assertEqual(sample(49, 49), imath.Color3f(1, 0, 0))
self.assertEqual(sample(50, 50), imath.Color3f(0, 1, 0))
self.assertEqual(sample(161, 161), imath.Color3f(0, 1, 0))
self.assertEqual(sample(162, 162), imath.Color3f(1, 0, 0))
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 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 testDisable(self):
c = GafferImage.Constant()
c["format"].setValue(GafferImage.Format(100, 100))
r = GafferImage.Resize()
r["in"].setInput(c["out"])
r["format"].setValue(GafferImage.Format(200, 200))
self.assertEqual(r["out"]["format"].getValue(),
GafferImage.Format(200, 200))
self.assertEqual(r["out"]["dataWindow"].getValue(),
IECore.Box2i(IECore.V2i(0), IECore.V2i(200)))
r["enabled"].setValue(False)
self.assertEqual(r["out"]["format"].getValue(),
GafferImage.Format(100, 100))
self.assertEqual(r["out"]["dataWindow"].getValue(),
IECore.Box2i(IECore.V2i(0), IECore.V2i(100)))
def testFormatDependencies(self):
r = GafferImage.Resize()
cs = GafferTest.CapturingSlot(r.plugDirtiedSignal())
r["format"].setValue(GafferImage.Format(100, 200, 2))
dirtiedPlugs = set(c[0] for c in cs)
self.assertTrue(r["out"]["format"] in dirtiedPlugs)
self.assertTrue(r["out"]["dataWindow"] in dirtiedPlugs)
def testMixParm( self ) : b = GafferImage.Constant() b["format"].setValue( GafferImage.Format( 50, 50, 1.0 ) ) b["color"].setValue( IECore.Color4f( 1, 0, 0, 1 ) ) a = GafferImage.Constant() a["format"].setValue( GafferImage.Format( 50, 50, 1.0 ) ) a["color"].setValue( IECore.Color4f( 0, 1, 0, 1 ) ) mask = GafferImage.Constant() mask["format"].setValue( GafferImage.Format( 50, 50, 1.0 ) ) mask["color"].setValue( IECore.Color4f( 0.5 ) ) m = GafferImage.Mix() m["in"][0].setInput( b["out"] ) m["in"][1].setInput( a["out"] ) def sample( x, y ) : redSampler = GafferImage.Sampler( m["out"], "R", m["out"]["format"].getValue().getDisplayWindow() ) greenSampler = GafferImage.Sampler( m["out"], "G", m["out"]["format"].getValue().getDisplayWindow() ) blueSampler = GafferImage.Sampler( m["out"], "B", m["out"]["format"].getValue().getDisplayWindow() ) return IECore.Color3f( redSampler.sample( x, y ), greenSampler.sample( x, y ), blueSampler.sample( x, y ), ) # Using just mix m["mix"].setValue( 0.75 ) self.assertEqual( sample( 49, 49 ), IECore.Color3f( 0.25, 0.75, 0 ) ) m["mix"].setValue( 0.25 ) self.assertEqual( sample( 49, 49 ), IECore.Color3f( 0.75, 0.25, 0 ) ) # Using mask multiplied with mix m["mask"].setInput( mask["out"] ) self.assertEqual( sample( 49, 49 ), IECore.Color3f( 0.875, 0.125, 0 ) ) # Using invalid channel of mask defaults to just mix m["maskChannel"].setValue( "DOES_NOT_EXIST" ) self.assertEqual( sample( 49, 49 ), IECore.Color3f( 0.75, 0.25, 0 ) )
def testDefaultFormat(self):
constant = GafferImage.Constant()
oslImage = GafferOSL.OSLImage()
oslImage["channels"].addChild(
Gaffer.NameValuePlug("", imath.Color3f(0.5, 0.6, 0.7)))
self.assertEqual(oslImage["out"]["dataWindow"].getValue(),
imath.Box2i(imath.V2i(0), imath.V2i(1920, 1080)))
self.assertEqual(
oslImage["out"]["format"].getValue().getDisplayWindow(),
imath.Box2i(imath.V2i(0), imath.V2i(1920, 1080)))
oslImage["defaultFormat"].setValue(
GafferImage.Format(imath.Box2i(imath.V2i(0), imath.V2i(5))))
self.assertEqual(oslImage["out"]["dataWindow"].getValue(),
imath.Box2i(imath.V2i(0), imath.V2i(5, 5)))
self.assertEqual(
oslImage["out"]["format"].getValue().getDisplayWindow(),
imath.Box2i(imath.V2i(0), imath.V2i(5, 5)))
self.assertEqual(
GafferImage.ImageAlgo.image(oslImage["out"])["G"],
IECore.FloatVectorData([0.6] * 25))
oslImage["in"].setInput(constant["out"])
self.assertEqual(oslImage["out"]["dataWindow"].getValue(),
imath.Box2i(imath.V2i(0), imath.V2i(1920, 1080)))
self.assertEqual(
oslImage["out"]["format"].getValue().getDisplayWindow(),
imath.Box2i(imath.V2i(0), imath.V2i(1920, 1080)))
constant["format"].setValue(
GafferImage.Format(imath.Box2i(imath.V2i(0), imath.V2i(4))))
self.assertEqual(oslImage["out"]["dataWindow"].getValue(),
imath.Box2i(imath.V2i(0), imath.V2i(4, 4)))
self.assertEqual(
oslImage["out"]["format"].getValue().getDisplayWindow(),
imath.Box2i(imath.V2i(0), imath.V2i(4, 4)))
self.assertEqual(
GafferImage.ImageAlgo.image(oslImage["out"])["G"],
IECore.FloatVectorData([0.6] * 16))
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 __formatLabel( self, fmt ) : if fmt == GafferImage.Format() : return "Default ( %s )" % GafferImage.FormatPlug.getDefaultFormat( self.getContext() ) else : name = GafferImage.Format.name( fmt ) if name : return "%s ( %s )" % ( name, str( fmt ) ) else : return "Custom"
