def testTextureCoordinates(self): r = IECoreRI.Renderer("test/IECoreRI/output/test.rib") with WorldBlock(r): r.setAttribute("ri:textureCoordinates", FloatVectorData([0, 1, 2, 3, 4, 5, 6, 7])) self.assertEqual(r.getAttribute("ri:textureCoordinates"), FloatVectorData([0, 1, 2, 3, 4, 5, 6, 7])) rib = "".join(file("test/IECoreRI/output/test.rib").readlines()) self.assertTrue('TextureCoordinates 0 1 2 3 4 5 6 7' in rib)
def testProcedural(self): r = IECoreRI.Renderer("test/IECoreRI/output/testProcedural.rib") r.worldBegin() p = SimpleProcedural(10.5) r.procedural(p) r.worldEnd() self.assertEqual(p.rendererTypeId, IECoreRI.Renderer.staticTypeId()) self.assertEqual(p.rendererTypeName, "IECoreRI::Renderer") self.assertEqual(p.rendererTypeName, IECoreRI.Renderer.staticTypeName())
def testRead(self): r = IECoreRI.PTCParticleReader() r['fileName'] = self.testfile pointCloud = r.read() self.assertEqual(type(pointCloud), IECore.PointsPrimitive) self.assertEqual(pointCloud.numPoints, 2975) self.assertEqual(len(pointCloud["P"].data), 2975) self.assertEqual( set(pointCloud.blindData()['PTCParticleIO'].keys()), set([ "boundingBox", "worldToEye", "worldToNdc", "variableTypes" ])) r['percentage'] = 50 pointCloud2 = r.read() self.assertEqual(len(pointCloud2["P"].data), 1502)
def testMissingPredefinedVariables(self): self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0) r = IECoreRI.SXRenderer() r.shader("surface", "test/IECoreRI/shaders/splineTest.sdl", {}) b = IECore.Box2i(IECore.V2i(0), IECore.V2i(100)) points = self.__rectanglePoints(b) del points["t"] # remove information the shader requires s = r.shade(points)
def testWrongSize(self): self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0) r = IECoreRI.SXRenderer() r.shader("surface", "test/IECoreRI/shaders/splineTest.sdl", {}) p = self.__rectanglePoints(IECore.Box2i(IECore.V2i(0), IECore.V2i(10))) del p["t"][-10:] self.assertRaises(RuntimeError, r.shade, p)
def _createRenderer(self): fileName = self.__fileName() directory = os.path.dirname(fileName) if directory: try: os.makedirs(directory) except OSError: # makedirs very unhelpfully raises an exception if # the directory already exists, but it might also # raise if it fails. we reraise only in the latter case. if not os.path.isdir(directory): raise return IECoreRI.Renderer(fileName)
def testMultipleDisplays(self): r = IECoreRI.Renderer("test/IECoreRI/output/test.rib") r.display("test.exr", "exr", "rgba", {"quantize": FloatVectorData([0, 0, 0, 0])}) r.display("z.exr", "exr", "z", {"quantize": FloatVectorData([0, 0, 0, 0])}) with WorldBlock(r): pass rib = "".join(file("test/IECoreRI/output/test.rib").readlines()) self.assertTrue("+z.exr" in rib)
def testCommands(self): r = IECoreRI.Renderer("test/IECoreRI/output/commands.rib") r.worldBegin() r.command("ri:readArchive", {"name": StringData("nameOfArchive")}) r.worldEnd() l = "".join( file("test/IECoreRI/output/commands.rib").readlines()).replace( "\n", "") self.failUnless('ReadArchive "nameOfArchive"' in l)
def testCompoundDataAttributes(self): r = IECoreRI.Renderer("test/IECoreRI/output/testAttributes.rib") with WorldBlock(r): r.setAttribute( "ri:displacementbound", { "sphere": 10.0, "coordinatesystem": "shader", }, ) lines = file("test/IECoreRI/output/testAttributes.rib").readlines() found = False for line in lines: if ("Attribute \"displacementbound\"" in line and "\"string coordinatesystem\" [ \"shader\" ]" in line and "\"float sphere\" [ 10 ]" in line): found = True self.failUnless(found) # check that we get appropriate warnings if not providing CompoundData r = IECoreRI.Renderer("test/IECoreRI/output/testAttributes.rib") with WorldBlock(r): c = CapturingMessageHandler() with c: r.setAttribute("ri:displacementbound", FloatData(10)) self.assertEqual(len(c.messages), 1) self.assertEqual(c.messages[0].level, Msg.Level.Warning)
def executeProcedural(name, version, args): procedural = IECore.ClassLoader.defaultProceduralLoader().load( name, version)() if procedural: IECore.ParameterParser().parse(args, procedural.parameters()) renderer = IECoreRI.Renderer() procedural.render(renderer, inAttributeBlock=False, withState=False, withGeometry=True, immediateGeometry=True)
def testMissingShaders(self): """Check that missing shaders don't throw an exception but print a message instead.""" with CapturingMessageHandler() as m: r = IECoreRI.Renderer("test/IECoreRI/output/missingShaders.rib") r.worldBegin() r.shader("surface", "aShaderWhichDoesntExist", {}) r.worldEnd() self.assertEqual(len(m.messages), 1) self.assert_("aShaderWhichDoesntExist" in m.messages[0].message)
def testUserOptions( self ): self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxUserOptionTest.sdl test/IECoreRI/shaders/sxUserOptionTest.sl" ), 0 ) points = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 1 ) ) ) r = IECoreRI.SXRenderer() r.shader( "surface", "test/IECoreRI/shaders/sxUserOptionTest.sdl", {} ) s = r.shade( points ) self.assertEqual( s["Ci"][0], IECore.Color3f( 0,0,0 ) ) r.setOption( "user:outputColor", IECore.FloatData( 1 ) ) s = r.shade( points ) self.assertEqual( s["Ci"][0], IECore.Color3f( 1,1,1 ) )
def testSetBucketSizeViaOptions( self ) : with CapturingMessageHandler() as mh : r = IECoreRI.Renderer( "test/IECoreRI/output/test.rib" ) r.setOption( "ri:limits:bucketsize", V2i( 32, 32 ) ) with WorldBlock( r ) : pass self.assertEqual( len( mh.messages ), 0 ) rib = "".join( file( "test/IECoreRI/output/test.rib" ).readlines() ) self.assertTrue( 'Option "limits" "integer bucketsize[2]" [ 32 32 ]' in rib )
def testStringPrimVars( self ) : r = IECoreRI.Renderer( "test/IECoreRI/output/stringPrimVars.rib" ) r.worldBegin() m = ObjectReader( "test/IECoreRI/data/stringPrimVars.cob" ).read() m.render( r ) r.worldEnd() l = "".join( file( "test/IECoreRI/output/stringPrimVars.rib" ).readlines() ).replace( "\n", "" ) self.failUnless( '"constant string ieGeneric_diffuse_Color_Textures" [ "woodTrain/woodTrainRed_v001_color_LIN.tdl" ]' in l ) self.failUnless( '"constant string ieGeneric_displacement_Textures" [ "woodTrain/woodTrain_v001_bump_LIN.tdl" ]' in l ) self.failUnless( '"constant string ieGeneric_reflection_Textures" [ "woodTrain/woodTrain_v001_bump_LIN.tdl" ]' in l )
def testZeroLength(self): self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0) r = IECoreRI.SXRenderer() r.shader("surface", "test/IECoreRI/shaders/splineTest.sdl", {}) p = self.__rectanglePoints(IECore.Box2i(IECore.V2i(0), IECore.V2i(10))) for k, v in p.items(): del v[:] self.assertRaises(RuntimeError, r.shade, p)
def testPlaneShade( self ) : r = IECoreRI.SXRenderer() self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxStTest.sdl test/IECoreRI/shaders/sxStTest.sl" ), 0 ) r.shader( "surface", "test/IECoreRI/shaders/sxStTest.sdl", {} ) data = r.shadePlane( IECore.V2i( 64, 64 ) ) del data["P"] del data["N"] self.assertEqual( data, IECore.Reader.create( "test/IECoreRI/data/sxOutput/shadePlaneCompoundData.cob" ).read() ) image = r.shadePlaneToImage( IECore.V2i( 64, 64 ) ) expectedImage = IECore.Reader.create( "test/IECoreRI/data/sxOutput/shadePlaneImage.exr" ).read() self.assertEqual( IECore.ImageDiffOp()( imageA=image, imageB=expectedImage, maxError=0 ), IECore.BoolData( False ) )
def testTransform( self ) : r = IECoreRI.Renderer( self.outputFileName ) with IECore.WorldBlock( r ) : c = IECore.CoordinateSystem( "helloWorld", IECore.MatrixTransform( IECore.M44f.createTranslated( IECore.V3f( 1 ) ) ), ) c.render( r ) l = "".join( file( self.outputFileName ).readlines() ) self.failUnless( "ScopedCoordinateSystem \"helloWorld\"" in l ) self.failUnless( "TransformBegin" in l ) self.failUnless( "TransformEnd" in l ) self.failUnless( "ConcatTransform" in l )
def testPrimVarNameValidation(self): m = IECore.MeshPrimitive.createPlane( IECore.Box2f(IECore.V2f(0, 0), IECore.V2f(1, 1))) e = IECoreRI.GXEvaluator(m) self.failIf("unlikely" in m) self.assertRaises( RuntimeError, e.evaluate, IECore.IntVectorData([0]), IECore.FloatVectorData([.5]), IECore.FloatVectorData([.5]), ["unlikely"], )
def testStringArrayOptions( self ): self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/sxStringArrayOptionTest.sdl test/IECoreRI/shaders/sxStringArrayOptionTest.sl" ), 0 ) points = self.__rectanglePoints( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 1 ) ) ) r = IECoreRI.SXRenderer() r.shader( "surface", "test/IECoreRI/shaders/sxStringArrayOptionTest.sdl", {} ) s = r.shade( points ) self.assertEqual( s["Ci"][0], IECore.Color3f( 0,0,0 ) ) r.setOption( "user:stringArray", IECore.StringVectorData( ["this","should","work"] ) ) s = r.shade( points ) self.assertEqual( s["Ci"][0], IECore.Color3f( 1,1,1 ) )
def testLightPrefixes( self ) : r = IECoreRI.Renderer( "test/IECoreRI/output/lightPrefixes.rib" ) with WorldBlock( r ) : r.light( "genericLight", "genericHandle", {} ) r.light( "ri:renderManLight", "renderManHandle", {} ) r.light( "ai:arnoldLight", "arnoldLight", {} ) del r rib = "".join( file( "test/IECoreRI/output/lightPrefixes.rib" ).readlines() ) self.assertTrue( 'LightSource "genericLight"' in rib ) self.assertTrue( 'LightSource "renderManLight"' in rib ) self.assertFalse( "arnold" in rib )
def testPixelAspectRatio( self ) : r = IECoreRI.Renderer( "test/IECoreRI/output/testCamera.rib" ) r.camera( "main", { "resolution" : IECore.V2i( 100, 200 ), "pixelAspectRatio" : 2.0, } ) with IECore.WorldBlock( r ) : pass l = "".join( file( "test/IECoreRI/output/testCamera.rib" ).readlines() ) l = " ".join( l.split() ) self.assertTrue( "Format 100 200 2" in l ) self.assertTrue( "ScreenWindow -1 1 -1 1" in l )
def testGetUserAttribute(self): r = IECoreRI.Renderer("test/IECoreRI/output/getUserAttribute.rib") o = { "user:f": FloatData(10), "user:i": IntData(100), "user:s": StringData("hello"), "user:c": Color3fData(Color3f(1, 0, 0)), "user:v": V3fData(V3f(1, 2, 3)), "user:m": M44fData(M44f.createTranslated(V3f(1, 2, 3))), } for k, v in o.items(): r.setAttribute(k, v) self.assertEqual(r.getAttribute(k), v)
def testMotionBlurCameraRib( self ) : r = IECoreRI.Renderer( "test/IECoreRI/output/testCamera.rib" ) with IECore.TransformBlock( r ) : with IECore.MotionBlock( r, [ 0, 1 ] ) : r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( -0.2, 0, 1 ) ) ) r.concatTransform( IECore.M44f.createTranslated( IECore.V3f( 0.2, 0, 1 ) ) ) r.camera( "main", { "shutter" : IECore.V2f( 0, 1 ) } ) r.worldBegin() r.worldEnd() l = "".join( file( "test/IECoreRI/output/testCamera.rib" ).readlines() ) self.assert_( "MotionBegin [ 0 1 ]" in l )
def testMultipleGrids(self): self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/sxGridTest.sdl test/IECoreRI/shaders/sxGridTest.sl" ), 0) r = IECoreRI.SXRenderer() b = IECore.Box2i(IECore.V2i(0), IECore.V2i(19, 9)) points = self.__rectanglePoints(b) with IECore.WorldBlock(r): r.shader("surface", "test/IECoreRI/shaders/sxGridTest", {}) # there are 20 x 10 points in the input, so this call should shade four 10 x 5 grids: r.shade(points, IECore.V2i(10, 5))
def testSLOReaderSupport(self): self.assertEqual( os.system( "shaderdl -o test/IECoreRI/shaders/coshaderTest.sdl test/IECoreRI/shaders/coshaderTest.sl" ), 0) s = IECoreRI.SLOReader("test/IECoreRI/shaders/coshaderTest.sdl").read() # old versions of 3delight reported the type as <unknown> (which we don't really want) but # new versions report it correctly as "shader". self.failUnless(s.type == "<unknown>" or s.type == "shader") k = s.parameters.keys() self.assertEqual(len(k), 2) self.failUnless("f" in k) self.failUnless("s" in k)
def testVVector(self): self.assertEqual( os.system( "shaderdl -Irsl -o test/IECoreRI/shaders/splineTest.sdl test/IECoreRI/shaders/splineTest.sl" ), 0) r = IECoreRI.SXRenderer() r.shader("surface", "test/IECoreRI/shaders/splineTest.sdl", {}) p = self.__rectanglePoints(IECore.Box2i(IECore.V2i(0), IECore.V2i(10))) # this should work, as you might want to use a V3f primvar called v (velocity) in # your shader: p["v"] = p["P"] r.shade(p)
def testDisplay(self): r = IECoreRI.Renderer("test/IECoreRI/output/testDisplay.rib") r.display("test.tif", "tiff", "rgba", {"quantize": FloatVectorData([0, 1, 0, 1])}) r.worldBegin() r.worldEnd() l = "".join( file("test/IECoreRI/output/testDisplay.rib").readlines()).replace( "\n", "") self.failUnless( 'Display "test.tif" "tiff" "rgba" "float quantize[4]" [ 0 1 0 1 ]' in l)
def testParameters(self): writer = IECoreRI.SHWDeepImageWriter(TestSHWDeepImageWriter.__output) self.assertEqual(writer.parameters()['fileName'].getTypedValue(), TestSHWDeepImageWriter.__output) self.assertEqual(writer.parameters()['channelNames'].getValue(), IECore.StringVectorData(["A"])) self.assertEqual(writer.parameters()['resolution'].getTypedValue(), IECore.V2i(2048, 1556)) self.assertEqual(writer.parameters()['tileSize'].getTypedValue(), IECore.V2i(32, 32)) self.assertEqual( writer.parameters()['worldToCameraMatrix'].getTypedValue(), IECore.M44f()) self.assertEqual( writer.parameters()['worldToNDCMatrix'].getTypedValue(), IECore.M44f())
def testGetOption( self ) : r = IECoreRI.Renderer( "test/IECoreRI/output/testGetOption.rib" ) r.camera( "main", { "resolution" : V2iData( V2i( 1024, 768 ) ) } ) r.setOption( "ri:shutter:offset", FloatData( 10 ) ) r.worldBegin() s = r.getOption( "shutter" ) self.assertEqual( s, V2fData( V2f( 0 ) ) ) self.assertEqual( r.getOption( "camera:resolution" ), V2iData( V2i( 1024, 768 ) ) ) self.assertEqual( r.getOption( "ri:shutter:offset" ), FloatData( 10 ) ) r.worldEnd()
def testAttributes(self): tests = [ # format is : name value expectedRib getAttributeShouldWork ("ri:shadingRate", FloatData(2), "ShadingRate 2", True), ("ri:matte", BoolData(0), "Matte 0", True), ("ri:matte", BoolData(1), "Matte 1", True), ("user:whatever", StringData("whatever"), "Attribute \"user\" \"string whatever\" [ \"whatever\" ]", True), ("ri:color", Color3fData(Color3f(0, 1, 1)), "Color [ 0 1 1 ]", False), ("color", Color3fData(Color3f(1, 2, 3)), "Color [ 1 2 3 ]", False), ("ri:opacity", Color3fData(Color3f(1, 1, 1)), "Opacity [ 1 1 1 ]", False), ("opacity", Color3fData(Color3f(0, 1, 0)), "Opacity [ 0 1 0 ]", False), ("ri:sides", IntData(1), "Sides 1", False), ("ri:geometricApproximation:motionFactor", FloatData(1), "GeometricApproximation \"motionfactor\" 1", False), ("ri:geometricApproximation:focusFactor", FloatData(1), "GeometricApproximation \"focusfactor\" 1", False), ("ri:cull:hidden", IntData(0), "Attribute \"cull\" \"int hidden\" [ 0 ]", False), ("name", StringData("oioi"), "Attribute \"identifier\" \"string name\" [ \"oioi\" ]", True), ("ri:trace:bias", FloatData(2), "Attribute \"trace\" \"float bias\" [ 2 ]", True), ("user:myString", StringData("wellHello"), "Attribute \"user\" \"string myString\" [ \"wellHello\" ]", True), ("ri:automaticInstancing", BoolData(True), "Attribute \"user\" \"int cortexAutomaticInstancing\" [ 1 ]", True), ] for t in tests: r = IECoreRI.Renderer("test/IECoreRI/output/testAttributes.rib") with WorldBlock(r): r.setAttribute(t[0], t[1]) if t[3]: self.assertEqual(r.getAttribute(t[0]), t[1]) l = "".join( file("test/IECoreRI/output/testAttributes.rib").readlines()) l = " ".join(l.split()) self.assert_(t[2] in l)
def testProceduralLevelInstancing( self ) : if IECoreRI.withRiProceduralV(): class InstanceTestProcedural( Renderer.Procedural ) : renderCount = 0 def __init__( self, instanceHash ) : Renderer.Procedural.__init__( self ) self.__instanceHash = instanceHash def bound( self ) : return Box3f( V3f( -10 ), V3f( 10 ) ) def render( self, renderer ) : InstanceTestProcedural.renderCount = InstanceTestProcedural.renderCount + 1 pass def hash( self ) : return self.__instanceHash r = IECoreRI.Renderer("") # give it a camera using the ray trace hider, and turn shareinstances on: r.camera( "main", { "resolution" : V2iData( V2i( 1024, 200 ) ), "screenWindow" : Box2fData( Box2f( V2f( -1 ), V2f( 1 ) ) ), "cropWindow" : Box2fData( Box2f( V2f( 0.1, 0.1 ), V2f( 0.9, 0.9 ) ) ), "clippingPlanes" : V2fData( V2f( 1, 1000 ) ), "projection" : StringData( "perspective" ), "projection:fov" : FloatData( 45 ), "ri:hider" : StringData( "raytrace" ), } ) r.setOption( "ri:trace:shareinstances", IntData( 1 ) ) # chuck a couple of procedurals at it: h1 = MurmurHash() h2 = MurmurHash() h1.append( "instance1" ) h2.append( "instance2" ) with WorldBlock( r ) : r.procedural( InstanceTestProcedural(h1) ) r.procedural( InstanceTestProcedural(h1) ) r.procedural( InstanceTestProcedural(h2) ) r.procedural( InstanceTestProcedural(h2) ) # only two unique instances here, as there were 2 unique hashes.... self.assertEqual( InstanceTestProcedural.renderCount, 2 ) InstanceTestProcedural.renderCount = 0 # the system shouldn't perform instancing when the hash method returns empty hashes: with WorldBlock( r ) : r.procedural( InstanceTestProcedural( MurmurHash() ) ) r.procedural( InstanceTestProcedural( MurmurHash() ) ) r.procedural( InstanceTestProcedural( MurmurHash() ) ) r.procedural( InstanceTestProcedural( MurmurHash() ) ) self.assertEqual( InstanceTestProcedural.renderCount, 4 )
def testParameterisedProceduralInstancing( self ) : if IECoreRI.withRiProceduralV(): class InstanceTestParamProcedural( ParameterisedProcedural ) : renderCount = 0 def __init__( self ) : ParameterisedProcedural.__init__( self, "Instancing test" ) self.parameters().addParameters( [ BoolParameter( name = "p1", description = "whatever.", defaultValue = True, ), StringParameter( name = "p2", description = "yup.", defaultValue = "blah" ), ] ) def doBound( self, args ) : return Box3f( V3f( -10 ), V3f( 10 ) ) def doRender( self, renderer, args ) : InstanceTestParamProcedural.renderCount = InstanceTestParamProcedural.renderCount + 1 pass r = IECoreRI.Renderer("") # give it a camera using the ray trace hider, and turn shareinstances on: r.camera( "main", { "resolution" : V2iData( V2i( 1024, 200 ) ), "screenWindow" : Box2fData( Box2f( V2f( -1 ), V2f( 1 ) ) ), "cropWindow" : Box2fData( Box2f( V2f( 0.1, 0.1 ), V2f( 0.9, 0.9 ) ) ), "clippingPlanes" : V2fData( V2f( 1, 1000 ) ), "projection" : StringData( "perspective" ), "projection:fov" : FloatData( 45 ), "ri:hider" : StringData( "raytrace" ), } ) r.setOption( "ri:trace:shareinstances", IntData( 1 ) ) # chuck a couple of procedurals at it: proc1 = InstanceTestParamProcedural() proc2 = InstanceTestParamProcedural() proc1["p1"].setValue( False ) proc1["p2"].setValue( StringData( "humpf" ) ) with WorldBlock( r ) : proc1.render( r ) proc2.render( r ) proc2.render( r ) proc2.render( r ) # only two unique instances here.... self.assertEqual( InstanceTestParamProcedural.renderCount, 2 )