def testChannelNames(self):
r = IECoreImage.ImageReader(
"test/IECoreImage/data/exr/AllHalfValues.exr")
c = r.channelNames()
self.assertEqual(c.staticTypeId(),
IECore.StringVectorData.staticTypeId())
self.assertEqual(len(c), 3)
self.assertTrue("R" in c)
self.assertTrue("G" in c)
self.assertTrue("B" in c)
r = IECoreImage.ImageReader(
"test/IECoreImage/data/exr/manyChannels.exr")
c = r.channelNames()
self.assertEqual(c.staticTypeId(),
IECore.StringVectorData.staticTypeId())
self.assertEqual(len(c), 7)
self.assertTrue("R" in c)
self.assertTrue("G" in c)
self.assertTrue("B" in c)
self.assertTrue("A" in c)
self.assertTrue("diffuse.red" in c)
self.assertTrue("diffuse.green" in c)
self.assertTrue("diffuse.blue" in c)
r = IECoreImage.ImageReader("thisFileDoesntExist.exr")
self.assertRaises(Exception, r.channelNames)
def testMissingChannels(self):
op = IECoreImage.ImageDiffOp()
w = IECore.Box2i(IECore.V2i(0, 0), IECore.V2i(99, 99))
f = IECore.FloatVectorData()
f.resize(100 * 100, 0)
imageA = IECoreImage.ImagePrimitive(w, w)
imageB = IECoreImage.ImagePrimitive(w, w)
# Both images have channel "R"
imageA["R"] = f
imageB["R"] = f
# Only imageA has channel "G"
imageA["G"] = f
res = op(imageA=imageA, imageB=imageB, skipMissingChannels=False)
self.assert_(res.value)
res = op(imageA=imageA, imageB=imageB, skipMissingChannels=True)
self.failIf(res.value)
def testOffsetDisplayWindows(self):
r = IECore.Reader.create("test/IECoreImage/data/exr/carPark.exr")
imageA = r.read()
imageB = r.read()
op = IECoreImage.ImageDiffOp()
res = op(imageA=imageA, imageB=imageB, alignDisplayWindows=False)
self.assertFalse(res.value)
# Offset the display and data windows.
offsetDisplayWindow = IECore.Box2i(
imageA.displayWindow.min + IECore.V2i(-261, 172),
imageA.displayWindow.max + IECore.V2i(-261, 172))
offsetDataWindow = IECore.Box2i(
imageA.dataWindow.min + IECore.V2i(-261, 172),
imageA.dataWindow.max + IECore.V2i(-261, 172))
imageA.displayWindow = offsetDisplayWindow
imageA.dataWindow = offsetDataWindow
# Compare the images again and they should fail as the display windows are different.
op = IECoreImage.ImageDiffOp()
res = op(imageA=imageA, imageB=imageB, alignDisplayWindows=False)
self.assertTrue(res.value)
# Compare the images again and they should not fail if "alignDisplayWindows" is turned on.
op = IECoreImage.ImageDiffOp()
res = op(imageA=imageA, imageB=imageB, alignDisplayWindows=True)
self.assertFalse(res.value)
def test( self ) : image = IECore.Reader.create( "test/IECoreImage/data/exr/carPark.exr" ).read() for n in ["R", "G", "B"] : p = image[n] p.data = IECore.DataCastOp()( object=image[n], targetType=IECore.FloatVectorData.staticTypeId() ) image[n] = p luminanceImage = IECoreImage.LuminanceOp()( input=image ) s = IECoreImage.MedianCutSampler()( image=luminanceImage, subdivisionDepth=4, projection=IECoreImage.MedianCutSampler.Projection.LatLong ) centroids = s["centroids"] areas = s["areas"] self.assertEqual( len( s ), 2 ) self.assertEqual( len( centroids ), len( areas ) ) self.assertEqual( len( centroids ), 16 ) self.assertTrue( centroids.isInstanceOf( IECore.V2fVectorData.staticTypeId() ) ) self.assertTrue( areas.isInstanceOf( IECore.Box2iVectorData.staticTypeId() ) ) dataWindow = luminanceImage.dataWindow areaSum = 0 for i in range( 0, len( centroids ) ) : c = centroids[i] c = imath.V2i( int(c.x), int(c.y) ) self.assertTrue( dataWindow.intersects( c ) ) self.assertTrue( areas[i].intersects( c ) ) s = areas[i].size() + imath.V2i( 1 ) areaSum += s.x * s.y self.assertEqual( areaSum, luminanceImage.channelSize() )
def testConstruction(self):
w = IECoreImage.ImageWriter(
IECoreImage.ImagePrimitive(),
"test/IECoreImage/data/exr/AllHalfValues.exr")
self.assertEqual(type(w), IECoreImage.ImageWriter)
w = IECore.Writer.create("test/IECoreImage/data/exr/AllHalfValues.exr")
self.assertEqual(type(w), IECoreImage.ImageWriter)
def testRoundTripTIF(self):
imgOrig = IECoreImage.ImageReader(
os.path.join("test", "IECoreImage", "data", "tiff",
"bluegreen_noise.400x300.tif")).read()
self.assertTrue(imgOrig.channelsValid())
self.assertTrue(isinstance(imgOrig["R"], IECore.FloatVectorData))
IECoreImage.ImageWriter(
imgOrig,
os.path.join("test", "IECoreImage", "data", "tiff",
"output.tif")).write()
self.assertTrue(
os.path.exists(
os.path.join("test", "IECoreImage", "data", "tiff",
"output.tif")))
reader = IECoreImage.ImageReader(
os.path.join("test", "IECoreImage", "data", "tiff", "output.tif"))
imgNew = reader.read()
self.assertTrue(imgNew.channelsValid())
self.assertTrue(isinstance(imgNew["R"], IECore.FloatVectorData))
self.__verifyImageRGB(imgOrig, imgNew, same=True)
reader["rawChannels"].setTypedValue(True)
imgRaw = reader.read()
self.assertTrue(imgRaw.channelsValid())
self.assertTrue(isinstance(imgRaw["R"], IECore.UCharVectorData))
self.__verifyImageRGB(imgRaw, imgNew, same=False)
self.__verifyImageRGB(imgRaw, imgOrig, same=False)
del reader
self.tearDown()
self.assertFalse(
os.path.exists(
os.path.join("test", "IECoreImage", "data", "tiff",
"output.tif")))
w = IECoreImage.ImageWriter(
imgRaw,
os.path.join("test", "IECoreImage", "data", "tiff", "output.tif"))
w['rawChannels'].setTypedValue(True)
w.write()
self.assertTrue(
os.path.exists(
os.path.join("test", "IECoreImage", "data", "tiff",
"output.tif")))
reader = IECoreImage.ImageReader(
os.path.join("test", "IECoreImage", "data", "tiff", "output.tif"))
reader["rawChannels"].setTypedValue(True)
imgRawNew = reader.read()
self.assertTrue(isinstance(imgRawNew["R"], IECore.UCharVectorData))
self.__verifyImageRGB(imgRawNew, imgNew, same=False)
self.__verifyImageRGB(imgRawNew, imgOrig, same=False)
self.__verifyImageRGB(imgRawNew, imgRaw, same=True)
def testDisplacementShader( self ) : undisplaced1 = self.__displacementRender( doDisplacement = False ) undisplaced2 = self.__displacementRender( doDisplacement = False ) displaced1 = self.__displacementRender( doDisplacement = True ) displaced2 = self.__displacementRender( doDisplacement = True ) self.assertEqual( IECoreImage.ImageDiffOp()( imageA=undisplaced1, imageB=undisplaced2, maxError=0.001 ), IECore.BoolData( False ) ) self.assertEqual( IECoreImage.ImageDiffOp()( imageA=displaced1, imageB=displaced2, maxError=0.001 ), IECore.BoolData( False ) ) self.assertEqual( IECoreImage.ImageDiffOp()( imageA=displaced1, imageB=undisplaced1, maxError=0.1 ), IECore.BoolData( True ) )
def testCs( self ) : i = IECoreImage.ImagePrimitive() i["Cs"] = IECore.Color3fVectorData( [ imath.Color3f( 1, 2, 3 ), imath.Color3f( 10, 11, 12 ) ] ) ii = IECoreImage.LuminanceOp()( input=i, weights=imath.Color3f( 1, 2, 3 ), removeColorChannels=False ) self.assert_( "Cs" in ii ) self.assert_( "Y" in ii ) self.assertAlmostEqual( ii["Y"][0], 14 ) self.assertAlmostEqual( ii["Y"][1], 68 )
def testConstruction(self):
w = IECoreImage.ImageWriter(
IECoreImage.ImagePrimitive(),
os.path.join("test", "IECoreImage", "data", "exr",
"AllHalValues.exr"))
self.assertIsInstance(w, IECoreImage.ImageWriter)
w = IECore.Writer.create(
os.path.join("test", "IECoreImage", "data", "exr",
"AllHalValues.exr"))
self.assertIsInstance(w, IECoreImage.ImageWriter)
def __init__(self):
IECore.Op.__init__(
self, "",
IECoreImage.ImagePrimitiveParameter(
"result", "", defaultValue=IECoreImage.ImagePrimitive()))
self.parameters().addParameter(
IECoreImage.ImagePrimitiveParameter(
"input",
"",
defaultValue=IECoreImage.ImagePrimitive(),
), )
def testKeepExistingValues( self ) : ph = GafferCortex.ParameterisedHolderNode() ph.setParameterised( IECoreImage.MedianCutSampler() ) ph["parameters"]["channelName"].setValue( "R" ) ph.setParameterised( IECoreImage.MedianCutSampler() ) self.assertEqual( ph["parameters"]["channelName"].getValue(), "Y" ) ph["parameters"]["channelName"].setValue( "R" ) ph.setParameterised( IECoreImage.MedianCutSampler(), keepExistingValues=True ) self.assertEqual( ph["parameters"]["channelName"].getValue(), "R" )
def testCanReadAndIsComplete( self ) : self.assertTrue( IECoreImage.ImageReader.canRead( "test/IECoreImage/data/exr/AllHalfValues.exr" ) ) self.assertFalse( IECoreImage.ImageReader.canRead( "thisFileDoesntExist.exr" ) ) r = IECoreImage.ImageReader( "test/IECoreImage/data/exr/AllHalfValues.exr" ) self.assertTrue( r.isComplete() ) r = IECoreImage.ImageReader( "test/IECoreImage/data/exr/incomplete.exr" ) self.assertFalse( r.isComplete() ) r = IECoreImage.ImageReader( "thisFileDoesntExist.exr" ) self.assertFalse( r.isComplete() )
def testDataAndDisplayWindows( self ) : r = IECoreImage.ImageReader( "test/IECoreImage/data/exr/AllHalfValues.exr" ) self.assertEqual( r.dataWindow(), imath.Box2i( imath.V2i( 0 ), imath.V2i( 255 ) ) ) self.assertEqual( r.displayWindow(), imath.Box2i( imath.V2i( 0 ), imath.V2i( 255 ) ) ) r = IECoreImage.ImageReader( "test/IECoreImage/data/exr/uvMapWithDataWindow.100x100.exr" ) self.assertEqual( r.dataWindow(), imath.Box2i( imath.V2i( 25 ), imath.V2i( 49 ) ) ) self.assertEqual( r.displayWindow(), imath.Box2i( imath.V2i( 0 ), imath.V2i( 99 ) ) ) r = IECoreImage.ImageReader( "thisFileDoesntExist.exr" ) self.assertRaises( Exception, r.dataWindow ) self.assertRaises( Exception, r.displayWindow )
def test( self ) : i = IECore.Reader.create( "test/IECoreImage/data/tiff/toTrace.tif" ).read() IECoreImage.ImageThinner()( input=i, copyInput=False ) IECoreImage.ImageWriter( i, "/tmp/newThinning.tif" ).write() ii = IECore.Reader.create( "test/IECoreImage/data/tiff/toTraceThinned.tif" ).read() i.blindData().clear() ii.blindData().clear() self.failUnless( i==ii )
def testTilesWithLeftovers( self ) : r = IECoreImage.ImageReader( "test/IECoreImage/data/tiff/tilesWithLeftovers.tif" ) i = r.read() i2 = IECoreImage.ImageReader( "test/IECoreImage/data/exr/tiffTileTestExpectedResults.exr" ).read() op = IECoreImage.ImageDiffOp() res = op( imageA = i, imageB = i2, maxError = 0.004, skipMissingChannels = False ) self.failIf( res.value )
def test(self):
b = imath.Box2i(imath.V2i(0), imath.V2i(1))
i = IECoreImage.ImagePrimitive(b, b)
i["Y"] = IECore.FloatVectorData([1, 2, 3, 4])
ii = IECoreImage.SummedAreaOp()(input=i,
channels=IECore.StringVectorData(["Y"
]))
yy = ii["Y"]
self.assertEqual(yy[0], 1)
self.assertEqual(yy[1], 3)
self.assertEqual(yy[2], 4)
self.assertEqual(yy[3], 10)
def testDefaults(self):
op = IECoreImage.ImageCropOp()
self.assertTrue(op['cropBox'].getValue().value.isEmpty())
self.assertEqual(op['resetOrigin'].getValue().value, True)
self.assertEqual(op['matchDataWindow'].getValue().value, True)
def testFromCompoundData( self ) : """ Test conversion from a CompoundData representation of an ImagePrimitive """ i = IECore.Reader.create( os.path.dirname( __file__ ) + "/images/colorBarsWithAlphaF512x512.exr" ).read() cd = IECore.CompoundData() cd["displayWindow"] = IECore.Box2iData( i.displayWindow ) cd["dataWindow"] = IECore.Box2iData( i.dataWindow ) cnd = IECore.CompoundData() for channel in i.channelNames() : cnd[ channel ] = i[ channel ] cd["channels"] = cnd t = IECoreGL.ToGLTextureConverter( cd ).convert() self.assertFalse( not t.isInstanceOf( IECoreGL.Texture.staticTypeId() ) ) ii = t.imagePrimitive() res = IECoreImage.ImageDiffOp()( imageA = i, imageB = ii, maxError = 0.01, skipMissingChannels = False ) self.assertFalse( res.value )
def testIfdGen(self):
# the image generated by this scene should be identical to the output of testWorldMesh()
ifd = _dir + "/output/testIfdGen.ifd"
r = IECoreMantra.Renderer(ifd)
r.display(_dir + "/output/testIfdGen.exr", "exr", "rgba", {
"variable": "Cf+Af",
"vextype": "vector4",
"channel": "C"
})
m = IECore.M44f().translate(IECore.V3f(0, 0, 6))
r.camera("main", {"projection": "perspective", "transform": m})
r.worldBegin()
self.__greenSquare(r)
r.worldEnd()
del r
self.assertTrue(os.path.isfile(ifd))
p = subprocess.Popen(['mantra'],
stdin=open(ifd),
stdout=subprocess.PIPE)
p.communicate()
imageCreated = IECore.Reader.create(_dir +
"/output/testIfdGen.exr").read()
expectedImage = IECore.Reader.create(_dir +
"/data/testWorldMesh.exr").read()
self.assertEqual(
IECoreImage.ImageDiffOp()(imageA=imageCreated,
imageB=expectedImage,
maxError=0.01), IECore.BoolData(False))
def testReadImage(self):
r = IECoreImage.ImageReader(
"test/IECoreImage/data/exr/uvMap.256x256.exr")
i = r.read()
self.assertEqual(i.typeId(), IECoreImage.ImagePrimitive.staticTypeId())
self.assertEqual(i.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(255)))
self.assertEqual(i.displayWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(255)))
self.assertTrue(i.channelsValid())
self.assertEqual(len(i), 3)
for c in ["R", "G", "B"]:
self.assertEqual(i[c].typeId(),
IECore.FloatVectorData.staticTypeId())
r = i["R"]
self.assertEqual(r[0], 0)
self.assertEqual(r[-1], 1)
g = i["G"]
self.assertEqual(g[0], 0)
self.assertEqual(g[-1], 1)
for b in i["B"]:
self.assertEqual(b, 0)
def testReadHeader(self):
r = IECoreImage.ImageReader(
"test/IECoreImage/data/exr/manyChannels.exr")
h = r.readHeader()
c = h['channelNames']
self.assertEqual(c.staticTypeId(),
IECore.StringVectorData.staticTypeId())
self.assertEqual(len(c), 7)
self.assertTrue("R" in c)
self.assertTrue("G" in c)
self.assertTrue("B" in c)
self.assertTrue("A" in c)
self.assertTrue("diffuse.red" in c)
self.assertTrue("diffuse.green" in c)
self.assertTrue("diffuse.blue" in c)
self.assertEqual(
h['displayWindow'],
IECore.Box2iData(
IECore.Box2i(IECore.V2i(0, 0), IECore.V2i(255, 255))))
self.assertEqual(
h['dataWindow'],
IECore.Box2iData(
IECore.Box2i(IECore.V2i(0, 0), IECore.V2i(255, 255))))
def __init__(self,
format,
dataWindow,
channelNames,
port,
extraParameters={}):
self.__format = format
parameters = {
"displayHost": "localHost",
"displayPort": str(port),
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
}
parameters.update(extraParameters)
with GafferTest.ParallelAlgoTest.UIThreadCallHandler() as h:
self.__driver = IECoreImage.ClientDisplayDriver(
self.__format.toEXRSpace(self.__format.getDisplayWindow()),
self.__format.toEXRSpace(dataWindow),
list(channelNames),
parameters,
)
# Expect UI thread call used to emit Display::driverCreatedSignal()
h.assertCalled()
h.assertDone()
def testExecuteWithImageInput(self):
fnOH = IECoreNuke.FnOpHolder.create("test", "imagePrimitiveInOut", 1)
self.assertEqual(fnOH.node().minimumInputs(), 1)
self.assertEqual(fnOH.node().maximumInputs(), 1)
check = nuke.nodes.CheckerBoard()
fnOH.node().setInput(0, check)
# get the image as output by the op
image = fnOH.execute()
# write the same image direct to disk without using the op
write = nuke.nodes.Write()
write.setInput(0, check)
write.knob("file").setValue("test/IECoreNuke/check.exr")
write.knob("channels").setValue("rgba")
nuke.execute(write, 1, 1)
# check that they are the same in terms of size and channel data.
# allow a slight difference due to one having been saved as half float and reloaded.
image2 = IECore.Reader.create("test/IECoreNuke/check.exr").read()
self.assertEqual(
IECoreImage.ImageDiffOp()(imageA=image,
imageB=image2,
maxError=0.001).value, False)
def __verifyImageRGB(self, imgNew, imgOrig, maxError=0.002, same=True):
self.assertEqual(type(imgNew), IECoreImage.ImagePrimitive)
if "R" in imgOrig:
self.assertTrue("R" in imgNew)
if "G" in imgOrig:
self.assertTrue("G" in imgNew)
if "B" in imgOrig:
self.assertTrue("B" in imgNew)
if "A" in imgOrig:
self.assertTrue("A" in imgNew)
if "Y" in imgOrig:
self.assertTrue("Y" in imgNew)
op = IECoreImage.ImageDiffOp()
res = op(imageA=imgNew,
imageB=imgOrig,
maxError=maxError,
skipMissingChannels=True)
if same:
self.assertFalse(res.value)
else:
self.assertTrue(res.value)
def testDiskRendering( self ) :
numPoints = 10
p = IECore.V3fVectorData( numPoints )
random.seed( 0 )
for i in range( 0, numPoints ) :
p[i] = IECore.V3f( random.random() * 4, random.random() * 4, random.random() * 4 )
p = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Vertex, p )
r = IECoreArnold.Renderer()
r.setOption( "ai:AA_samples", IECore.IntData( 9 ) )
r.camera( "main", {
"projection" : IECore.StringData( "orthographic" ),
"resolution" : IECore.V2iData( IECore.V2i( 256 ) ),
"clippingPlanes" : IECore.V2fData( IECore.V2f( 1, 1000 ) ),
"screenWindow" : IECore.Box2fData( IECore.Box2f( IECore.V2f( -3 ), IECore.V2f( 3 ) ) )
}
)
r.display( "test", "ieDisplay", "rgba", { "driverType" : "ImageDisplayDriver", "handle" : "testHandle" } )
with IECore.WorldBlock( r ) :
r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( -2, -2, -10 ) ) )
r.points( numPoints, { "P" : p } )
image = IECoreImage.ImageDisplayDriver.removeStoredImage( "testHandle" )
del image["A"]
expectedImage = IECore.Reader.create( os.path.dirname( __file__ ) + "/data/pointsImages/points.tif" ).read()
self.assertEqual( IECoreImage.ImageDiffOp()( imageA=image, imageB=expectedImage, maxError=0.01 ), IECore.BoolData( False ) )
def __makeIntImage(self,
dataWindow,
displayWindow,
dataType=IECore.UIntVectorData,
maxInt=2**32 - 1):
img = IECoreImage.ImagePrimitive(dataWindow, displayWindow)
w = dataWindow.max().x - dataWindow.min().x + 1
h = dataWindow.max().y - dataWindow.min().y + 1
area = w * h
R = dataType(area)
G = dataType(area)
B = dataType(area)
offset = 0
for y in range(0, h):
for x in range(0, w):
R[offset] = int(maxInt * float(x) / (w - 1))
G[offset] = int(maxInt * float(y) / (h - 1))
B[offset] = 0
offset = offset + 1
img["R"] = R
img["G"] = G
img["B"] = B
return img
def test(self):
dataWindow = IECore.Box2i(IECore.V2i(0), IECore.V2i(74))
image = IECoreImage.ImagePrimitive(dataWindow, dataWindow)
red = IECore.FloatVectorData()
green = IECore.FloatVectorData()
blue = IECore.FloatVectorData()
image["R"] = red
image["G"] = green
image["B"] = blue
for y in range(0, 75):
for x in range(0, 75):
red.append(x)
green.append(y)
blue.append(0)
imageNode = GafferImage.ObjectToImage()
imageNode["object"].setValue(image)
sampler = GafferImage.ImageSampler()
sampler["image"].setInput(imageNode["out"])
hashes = set()
for x in range(0, 75):
for y in range(0, 75):
sampler["pixel"].setValue(IECore.V2f(x + 0.5, y + 0.5))
# the flip in y is necessary as gaffer image coordinates run bottom->top and
# cortex image coordinates run top->bottom.
self.assertEqual(sampler["color"].getValue(),
IECore.Color4f(x, 74 - y, 0, 0))
hashes.add(str(sampler["color"].hash()))
self.assertEqual(len(hashes), 75 * 75)
def testTransfer( self ):
img = IECore.Reader.create( os.path.join( "test", "IECoreImage", "data", "tiff", "bluegreen_noise.400x300.tif" ) )()
self.assertEqual( img.keys(), [ 'B', 'G', 'R' ] )
red = img['R']
green = img['G']
blue = img['B']
width = img.dataWindow.max().x - img.dataWindow.min().x + 1
params = IECore.CompoundData()
params['displayHost'] = IECore.StringData('localhost')
params['displayPort'] = IECore.StringData( '1559' )
params["remoteDisplayType"] = IECore.StringData( "ImageDisplayDriver" )
params["handle"] = IECore.StringData( "myHandle" )
params["header:myMetadata"] = IECore.StringData( "Metadata!" )
idd = IECoreImage.ClientDisplayDriver( img.displayWindow, img.dataWindow, list( img.channelNames() ), params )
buf = IECore.FloatVectorData( width * 3 )
for i in range( 0, img.dataWindow.max().y - img.dataWindow.min().y + 1 ):
self.__prepareBuf( buf, width, i*width, red, green, blue )
idd.imageData( imath.Box2i( imath.V2i( img.dataWindow.min().x, i + img.dataWindow.min().y ), imath.V2i( img.dataWindow.max().x, i + img.dataWindow.min().y) ), buf )
idd.imageClose()
newImg = IECoreImage.ImageDisplayDriver.removeStoredImage( "myHandle" )
params["clientPID"] = IECore.IntData( os.getpid() )
# only data prefixed by 'header:' will come through as blindData/metadata
self.assertEqual( newImg.blindData(), IECore.CompoundData({"myMetadata": IECore.StringData( "Metadata!" )}) )
# remove blindData for comparison
newImg.blindData().clear()
img.blindData().clear()
self.assertEqual( newImg, img )
def testAcceptsRepeatedData( self ) :
window = imath.Box2i( imath.V2i( 0 ), imath.V2i( 15 ) )
dd = IECoreImage.ClientDisplayDriver(
window, window,
[ "Y" ],
IECore.CompoundData( {
"displayHost" : "localhost",
"displayPort" : "1559",
"remoteDisplayType" : "ImageDisplayDriver",
"handle" : "myHandle"
} )
)
self.assertEqual( dd.acceptsRepeatedData(), True )
y = IECore.FloatVectorData( [ 1 ] * 16 * 16 )
dd.imageData( window, y )
y = IECore.FloatVectorData( [ 0.5 ] * 16 * 16 )
dd.imageData( window, y )
dd.imageClose()
i = IECoreImage.ImageDisplayDriver.removeStoredImage( "myHandle" )
self.assertEqual( i["Y"], y )
def performCurvesTest(self, curvesPrimitive, expectedImage):
r = IECoreArnold.Renderer()
r.setOption("ai:AA_samples", IECore.IntData(3))
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
with IECore.TransformBlock(r):
r.concatTransform(IECore.M44f.createTranslated(IECore.V3f(0, 0,
2)))
r.camera(
"main", {
"resolution": IECore.V2i(512),
"projectin": "orthographic",
"screenWindow": IECore.Box2f(IECore.V2f(0), IECore.V2f(1)),
})
with IECore.WorldBlock(r):
curvesPrimitive.render(r)
image = IECoreImage.ImageDisplayDriver.removeStoredImage("test")
del image["A"]
expectedImage = IECore.Reader.create(expectedImage).read()
self.assertEqual(
IECoreImage.ImageDiffOp()(imageA=image,
imageB=expectedImage,
maxError=0.01), IECore.BoolData(False))
