def testConstructors(self): """Test TransformationMatrixf constructors""" a = IECore.TransformationMatrixf() self.assertEqual(a.transform, imath.M44f()) a = IECore.TransformationMatrixf(imath.V3f(2, 2, 2), imath.Eulerf(), imath.V3f(1, 0, 0)) self.assert_( a.transform.equalWithAbsError( imath.M44f().scale(imath.V3f(2, 2, 2)) * imath.M44f().translate(imath.V3f(1, 0, 0)), 0.01)) b = IECore.TransformationMatrixf(a) self.assertEqual(a.transform, b.transform)
def testTransform(self): sphere = IECoreScene.SpherePrimitive() originalRootBound = sphere.bound() originalRootBound.setMin(originalRootBound.min() + imath.V3f(1, 0, 0)) originalRootBound.setMax(originalRootBound.max() + imath.V3f(1, 0, 0)) input = GafferSceneTest.CompoundObjectSource() input["in"].setValue( IECore.CompoundObject({ "bound": IECore.Box3fData(originalRootBound), "children": { "sphere": { "object": sphere, "bound": IECore.Box3fData(sphere.bound()), "transform": IECore.M44fData(imath.M44f().translate( imath.V3f(1, 0, 0))), } } })) group = GafferScene.Group() group["in"][0].setInput(input["out"]) group["transform"]["translate"].setValue(imath.V3f(0, 1, 0)) self.assertEqual(group["name"].getValue(), "group") groupedRootBound = imath.Box3f(originalRootBound.min(), originalRootBound.max()) groupedRootBound.setMin(groupedRootBound.min() + imath.V3f(0, 1, 0)) groupedRootBound.setMax(groupedRootBound.max() + imath.V3f(0, 1, 0)) self.assertEqual(group["out"].object("/"), IECore.NullObject()) self.assertEqual(group["out"].transform("/"), imath.M44f()) self.assertEqual(group["out"].bound("/"), groupedRootBound) self.assertEqual(group["out"].childNames("/"), IECore.InternedStringVectorData(["group"])) self.assertEqual(group["out"].object("/group"), IECore.NullObject()) self.assertEqual(group["out"].transform("/group"), imath.M44f().translate(imath.V3f(0, 1, 0))) self.assertEqual(group["out"].bound("/group"), originalRootBound) self.assertEqual(group["out"].childNames("/group"), IECore.InternedStringVectorData(["sphere"])) self.assertEqual(group["out"].object("/group/sphere"), sphere) self.assertEqual(group["out"].transform("/group/sphere"), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual(group["out"].bound("/group/sphere"), sphere.bound()) self.assertEqual(group["out"].childNames("/group/sphere"), IECore.InternedStringVectorData())
def testConstructors(self): """Test Eulerf constructors""" # e = imath.Eulerf() self.assertEqual(e.x, 0) self.assertEqual(e.y, 0) self.assertEqual(e.z, 0) self.assertEqual(e.order(), imath.Eulerf.Order.XYZ) # ecopy = imath.Eulerf(e) self.assertEqual(ecopy.x, 0) self.assertEqual(ecopy.y, 0) self.assertEqual(ecopy.z, 0) self.assertEqual(ecopy.order(), imath.Eulerf.Order.XYZ) # e = imath.Eulerf(imath.Eulerf.Order.ZYX) self.assertEqual(e.order(), imath.Eulerf.Order.ZYX) # e = imath.Eulerf(imath.V3f(0, 0, 0)) self.assertEqual(e.order(), imath.Eulerf.Order.XYZ) e = imath.Eulerf(imath.V3f(0, 0, 0), imath.Eulerf.Order.ZYX) self.assertEqual(e.order(), imath.Eulerf.Order.ZYX) # e = imath.Eulerf(0, 0, 0) e = imath.Eulerf(imath.V3f(0, 0, 0)) self.assertEqual(e.order(), imath.Eulerf.Order.XYZ) e = imath.Eulerf(0, 0, 0, imath.Eulerf.Order.ZYX) self.assertEqual(e.order(), imath.Eulerf.Order.ZYX) # e = imath.Eulerf(imath.M33f()) e = imath.Eulerf(imath.V3f(0, 0, 0)) self.assertEqual(e.order(), imath.Eulerf.Order.XYZ) e = imath.Eulerf(imath.M33f(), imath.Eulerf.Order.ZYX) self.assertEqual(e.order(), imath.Eulerf.Order.ZYX) # e = imath.Eulerf(imath.M44f()) e = imath.Eulerf(imath.V3f(0, 0, 0)) self.assertEqual(e.order(), imath.Eulerf.Order.XYZ) e = imath.Eulerf(imath.M44f(), imath.Eulerf.Order.ZYX) self.assertEqual(e.order(), imath.Eulerf.Order.ZYX)
def decompressed( self ) : names = IECore.StringVectorData( [ 'jointA', 'jointB', 'jointC' ] ) poses = IECore.M44fVectorData( [imath.M44f(),imath.M44f(),imath.M44f()] ) offsets = IECore.IntVectorData( [0, 3, 6] ) counts = IECore.IntVectorData( [3, 3, 3] ) indices = IECore.IntVectorData( [0, 1, 2, 0, 1, 2, 0, 1, 2] ) weights = IECore.FloatVectorData( [0.5, 0.5, 0.0, 0.2, 0.8, 0.0, 0.0, 1.0, 0.0] ) ssd = IECoreScene.SmoothSkinningData( names, poses, offsets, counts, indices, weights ) return ssd
def doTest(depthTest, r, g, b): renderer = IECoreGL.Renderer() renderer.setOption("gl:mode", IECore.StringData("immediate")) renderer.setOption( "gl:searchPath:shader", IECore.StringData(os.path.dirname(__file__) + "/shaders")) renderer.camera( "main", { "projection": IECore.StringData("orthographic"), "resolution": IECore.V2iData(imath.V2i(256)), "clippingPlanes": IECore.V2fData(imath.V2f(1, 1000)), "screenWindow": IECore.Box2fData(imath.Box2f(imath.V2f(-1), imath.V2f(1))) }) renderer.display( os.path.dirname(__file__) + "/output/depthTest.tif", "tif", "rgba", {}) m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))) with IECoreScene.WorldBlock(renderer): renderer.setAttribute("gl:depthTest", IECore.BoolData(depthTest)) renderer.concatTransform(imath.M44f().translate( imath.V3f(0, 0, -1))) renderer.shader( "surface", "color", {"colorValue": IECore.Color3fData(imath.Color3f(1, 0, 0))}) m.render(renderer) renderer.concatTransform(imath.M44f().translate( imath.V3f(0, 0, -1))) renderer.shader( "surface", "color", {"colorValue": IECore.Color3fData(imath.Color3f(0, 1, 0))}) m.render(renderer) i = IECore.Reader.create( os.path.dirname(__file__) + "/output/depthTest.tif").read() for p in i["R"]: self.assertEqual(p, r) for p in i["G"]: self.assertEqual(p, g) for p in i["B"]: self.assertEqual(p, b)
def createSSD(self, offsets, counts, indices, weights): names = IECore.StringVectorData( ["|joint1", "|joint1|joint2", "|joint1|joint2|joint3"]) poses = IECore.M44fVectorData([ imath.M44f(1, -0, 0, -0, -0, 1, -0, 0, 0, -0, 1, -0, -0, 2, -0, 1), imath.M44f(1, -0, 0, -0, -0, 1, -0, 0, 0, -0, 1, -0, -0, 0, -0, 1), imath.M44f(1, -0, 0, -0, -0, 1, -0, 0, 0, -0, 1, -0, -0, -2, -0, 1) ]) return IECoreScene.SmoothSkinningData(names, poses, offsets, counts, indices, weights)
def testTwoLevels(self): sphere = IECoreScene.SpherePrimitive() input = GafferSceneTest.CompoundObjectSource() input["in"].setValue( IECore.CompoundObject({ "bound": IECore.Box3fData(sphere.bound()), "children": { "group": { "bound": IECore.Box3fData(sphere.bound()), "children": { "sphere": { "bound": IECore.Box3fData(sphere.bound()), "object": sphere, }, }, }, }, }), ) group = GafferScene.Group() group["in"][0].setInput(input["out"]) group["name"].setValue("topLevel") self.assertEqual(group["name"].getValue(), "topLevel") self.assertEqual(group["out"].object("/"), IECore.NullObject()) self.assertEqual(group["out"].transform("/"), imath.M44f()) self.assertEqual(group["out"].bound("/"), sphere.bound()) self.assertEqual(group["out"].childNames("/"), IECore.InternedStringVectorData(["topLevel"])) self.assertEqual(group["out"].object("/topLevel"), IECore.NullObject()) self.assertEqual(group["out"].transform("/topLevel"), imath.M44f()) self.assertEqual(group["out"].bound("/topLevel"), sphere.bound()) self.assertEqual(group["out"].childNames("/topLevel"), IECore.InternedStringVectorData(["group"])) self.assertEqual(group["out"].object("/topLevel/group"), IECore.NullObject()) self.assertEqual(group["out"].transform("/topLevel/group"), imath.M44f()) self.assertEqual(group["out"].bound("/topLevel/group"), sphere.bound()) self.assertEqual(group["out"].childNames("/topLevel/group"), IECore.InternedStringVectorData(["sphere"])) self.assertEqual(group["out"].object("/topLevel/group/sphere"), sphere) self.assertEqual(group["out"].transform("/topLevel/group/sphere"), imath.M44f()) self.assertEqual(group["out"].bound("/topLevel/group/sphere"), sphere.bound()) self.assertEqual(group["out"].childNames("/topLevel/group/sphere"), IECore.InternedStringVectorData())
def testAccessors( self ) : m = imath.M44f( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 ) b = IECore.CubicBasisf( m, 10 ) self.assertEqual( b.matrix, m ) self.assertEqual( b.step, 10 ) m2 = imath.M44f( 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ) b.matrix = m2 self.assertEqual( b.matrix, m2 ) b.step = 1 self.assertEqual( b.matrix, m2 )
def testCompute( self ) : c = GafferScene.Cube() self.assertEqual( c["out"].object( "/" ), IECore.NullObject() ) self.assertEqual( c["out"].transform( "/" ), imath.M44f() ) self.assertEqual( c["out"].bound( "/" ), imath.Box3f( imath.V3f( -0.5, -0.5, -0.5 ), imath.V3f( 0.5, 0.5, 0.5 ) ) ) self.assertEqual( c["out"].childNames( "/" ), IECore.InternedStringVectorData( [ "cube" ] ) ) self.assertEqual( c["out"].object( "/cube" ), IECoreScene.MeshPrimitive.createBox( imath.Box3f( imath.V3f( -0.5 ), imath.V3f( 0.5 ) ) ) ) self.assertEqual( c["out"].transform( "/cube" ), imath.M44f() ) self.assertEqual( c["out"].bound( "/cube" ), imath.Box3f( imath.V3f( -0.5, -0.5, -0.5 ), imath.V3f( 0.5, 0.5, 0.5 ) ) ) self.assertEqual( c["out"].childNames( "/cube" ), IECore.InternedStringVectorData() )
def compressedAfterIndexed(self): names = IECore.StringVectorData(['jointA', 'jointB', 'jointC']) poses = IECore.M44fVectorData( [imath.M44f(1), imath.M44f(2), imath.M44f(3)]) offsets = IECore.IntVectorData([0, 1, 2, 2, 3]) counts = IECore.IntVectorData([1, 1, 0, 1, 2]) indices = IECore.IntVectorData([0, 0, 2, 0, 2]) weights = IECore.FloatVectorData([0.7, 0.2, 0.8, 0.4, 0.4]) return IECoreScene.SmoothSkinningData(names, poses, offsets, counts, indices, weights)
def testParentAndChildInSameEditScope( self ) : script = Gaffer.ScriptNode() script["cube"] = GafferScene.Cube() script["cube"]["transform"]["translate"].setValue( imath.V3f( 0, 1, 0 ) ) script["group"] = GafferScene.Group() script["group"]["in"][0].setInput( script["cube"]["out"] ) script["editScope"] = Gaffer.EditScope() script["editScope"].setup( script["group"]["out"] ) script["editScope"]["in"].setInput( script["group"]["out"] ) view = GafferSceneUI.SceneView() view["in"].setInput( script["editScope"]["out"] ) view["editScope"].setInput( script["editScope"]["out"] ) groupTransformEdit = GafferScene.EditScopeAlgo.acquireTransformEdit( script["editScope"], "/group" ) groupTransformEdit.rotate["y"].setValue( 90 ) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher( [ "/group/cube" ] ) ) tool = GafferSceneUI.TranslateTool( view ) tool["active"].setValue( True ) self.assertTrue( tool.handlesTransform().equalWithAbsError( groupTransformEdit.matrix() * imath.M44f().translate( imath.V3f( 0, 1, 0 ) ), 0.00001 ) ) tool.translate( imath.V3f( 1, 0, 0 ) ) self.assertTrue( script["editScope"]["out"].fullTransform( "/group/cube" ).equalWithAbsError( imath.M44f().translate( imath.V3f( 1, 1, 0 ) ) * groupTransformEdit.matrix(), 0.00001 ) ) tool.translate( imath.V3f( 1, 0, 0 ) ) self.assertTrue( script["editScope"]["out"].fullTransform( "/group/cube" ).equalWithAbsError( imath.M44f().translate( imath.V3f( 2, 1, 0 ) ) * groupTransformEdit.matrix(), 0.00001 ) )
def testInstances(self): r = IECoreGL.Renderer() r.instanceBegin( "instanceA", {} ) r.concatTransform( imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) r.transformBegin() r.concatTransform( imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) r.sphere( 1, -1, 1, 360, {} ) r.concatTransform( imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) r.sphere( 1, -1, 1, 360, {} ) r.transformEnd() r.concatTransform( imath.M44f().translate( imath.V3f( -1, 0, 0 ) ) ) r.sphere( 1, -1, 1, 360, {} ) r.instanceEnd() r.instanceBegin( "instanceB", {} ) r.concatTransform( imath.M44f().translate( imath.V3f( 0, 0, 10 ) ) ) r.instance( "instanceA" ) r.concatTransform( imath.M44f().translate( imath.V3f( 0, 0, 20 ) ) ) r.instance( "instanceA" ) r.instanceEnd() r.setOption( "gl:mode", IECore.StringData( "deferred" ) ) r.worldBegin() r.concatTransform( imath.M44f().translate( imath.V3f( 0, 5, 0 ) ) ) r.instance( "instanceB" ) r.setTransform( imath.M44f().translate( imath.V3f( 0, 10, 0 ) ) ) r.instance( "instanceB" ) r.worldEnd() g = r.scene().root() self.assertEqual( self.__countChildrenRecursive( g ), 12 ) self.assertTrue( g.bound().min().equalWithAbsError( imath.V3f( -1, 4, 9 ), 0.001 ) ) self.assertTrue( g.bound().max().equalWithAbsError( imath.V3f( 4, 11, 31 ), 0.001 ) )
def testCompute( self ) : s = GafferScene.Sphere() s["type"].setValue( GafferScene.Sphere.Type.Primitive ) self.assertEqual( s["out"].object( "/" ), IECore.NullObject() ) self.assertEqual( s["out"].transform( "/" ), imath.M44f() ) self.assertEqual( s["out"].bound( "/" ), imath.Box3f( imath.V3f( -1 ), imath.V3f( 1 ) ) ) self.assertEqual( s["out"].childNames( "/" ), IECore.InternedStringVectorData( [ "sphere" ] ) ) self.assertEqual( s["out"].object( "/sphere" ), IECoreScene.SpherePrimitive( 1 ) ) self.assertEqual( s["out"].transform( "/sphere" ), imath.M44f() ) self.assertEqual( s["out"].bound( "/sphere" ), imath.Box3f( imath.V3f( -1 ), imath.V3f( 1 ) ) ) self.assertEqual( s["out"].childNames( "/sphere" ), IECore.InternedStringVectorData() )
def testNegativeLocalScale(self): script = Gaffer.ScriptNode() script["plane"] = GafferScene.Plane() script["plane"]["transform"]["scale"]["z"].setValue(-10) view = GafferSceneUI.SceneView() view["in"].setInput(script["plane"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/plane"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) tool["orientation"].setValue(tool.Orientation.Local) # We want the direction of the handles to reflect the # flipped scale, but not its magnitude. self.assertTrue(tool.handlesTransform().equalWithAbsError( imath.M44f().scale(imath.V3f(1, 1, -1)), 0.000001)) # And the handles need to move the object in the right # direction still. with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(0, 45, 0)) self.assertTrue(script["plane"]["transform"] ["rotate"].getValue().equalWithAbsError( imath.V3f(0, -45, 0), 0.0001)) script.undo() # When orientation is Parent or World, the scale should # not be reflected in the handles. for orientation in (tool.Orientation.World, tool.Orientation.Parent): tool["orientation"].setValue(orientation) self.assertEqual(tool.handlesTransform(), imath.M44f()) with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(0, 45, 0)) self.assertTrue(script["plane"]["transform"] ["rotate"].getValue().equalWithAbsError( imath.V3f(0, 45, 0), 0.0001)) script.undo()
def testPrimitiveInterpolation(self): m1 = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))) m2 = IECoreScene.TransformOp()(input=m1, matrix=IECore.M44fData( imath.M44f().scale(imath.V3f(2)))) m3 = IECore.linearObjectInterpolation(m1, m2, 0.5) self.assertEqual( m3, IECoreScene.TransformOp()(input=m1, matrix=IECore.M44fData( imath.M44f().scale(imath.V3f(1.5)))))
def testTransformationMotionBlur( self ) : transformSequence = appleseed.TransformSequence() IECoreAppleseed.TransformAlgo.makeTransformSequence( [ 0.25, 0.5, 0.75 ], [ imath.M44f().translate( imath.V3f( 0 ) ), imath.M44f().translate( imath.V3f( 1 ) ), imath.M44f().translate( imath.V3f( 2 ) ) ], transformSequence ) transforms = transformSequence.transforms() self.assertTrue( len( transforms ) == 3 ) self.assertTrue( transforms[0][0] == 0.25 ) self.assertTrue( transforms[1][0] == 0.50 ) self.assertTrue( transforms[2][0] == 0.75 )
def createSSD(self, weights): names = IECore.StringVectorData(['jointA', 'jointB', 'jointC']) poses = IECore.M44fVectorData( [imath.M44f(1), imath.M44f(2), imath.M44f(3)]) offsets = IECore.IntVectorData([0, 2, 5, 6, 8]) counts = IECore.IntVectorData([2, 3, 1, 2, 3]) indices = IECore.IntVectorData([0, 1, 0, 1, 2, 1, 1, 2, 0, 1, 2]) ssd = IECoreScene.SmoothSkinningData(names, poses, offsets, counts, indices, weights) return ssd
def testTransform(self): s = GafferScene.Sphere() s["type"].setValue(GafferScene.Sphere.Type.Primitive) s["transform"]["translate"].setValue(imath.V3f(1, 0, 0)) self.assertEqual(s["out"].transform("/"), imath.M44f()) self.assertEqual(s["out"].transform("/sphere"), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual(s["out"].bound("/"), imath.Box3f(imath.V3f(0, -1, -1), imath.V3f(2, 1, 1))) self.assertEqual(s["out"].bound("/sphere"), imath.Box3f(imath.V3f(-1), imath.V3f(1)))
def testSkinClusterInfluencesWereRenamed(self): (sc, sc2) = self.buildTestSetup() fromConverter = IECoreMaya.FromMayaSkinClusterConverter.create(sc) fromConverter.parameters()["influenceName"].setValue( IECoreMaya.FromMayaSkinClusterConverter.InfluenceName.Partial) ssd = fromConverter.convert() self.assertEqual( ssd.influenceNames(), IECore.StringVectorData(['joint1', 'joint2', 'joint3'])) ssd.validate() maya.cmds.rename('joint2', 'fakeJoint') newPose = IECore.M44fVectorData([ imath.M44f(*maya.cmds.getAttr('skinCluster1.bindPreMatrix[0]')), imath.M44f(*maya.cmds.getAttr('skinCluster1.bindPreMatrix[2]')), imath.M44f(*maya.cmds.getAttr('skinCluster1.bindPreMatrix[1]')) ]) toConverter = IECoreMaya.ToMayaSkinClusterConverter.create(ssd) toConverter.parameters()["ignoreMissingInfluences"].setTypedValue(True) toConverter.convert(sc) fromConverter = IECoreMaya.FromMayaSkinClusterConverter.create(sc) fromConverter.parameters()["influenceName"].setValue( IECoreMaya.FromMayaSkinClusterConverter.InfluenceName.Partial) ssd2 = fromConverter.convert() self.assertEqual( ssd2.influenceNames(), IECore.StringVectorData(['joint1', 'joint3', 'fakeJoint'])) self.assertEqual(ssd2.influencePose(), newPose) self.assertEqual( ssd2.pointIndexOffsets(), IECore.IntVectorData( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])) self.assertEqual( ssd2.pointInfluenceCounts(), IECore.IntVectorData( [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])) self.assertEqual( ssd2.pointInfluenceIndices(), IECore.IntVectorData( [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0])) newWeights = IECore.FloatVectorData([ ssd.pointInfluenceWeights()[x] for x in range(0, ssd.pointInfluenceWeights().size()) if ssd.pointInfluenceIndices()[x] != 1 ]) self.assertEqual(ssd2.pointInfluenceWeights(), newWeights)
def testTransform(self): c = GafferScene.Cube() c["transform"]["translate"].setValue(imath.V3f(1, 0, 0)) self.assertEqual(c["out"].transform("/"), imath.M44f()) self.assertEqual(c["out"].transform("/cube"), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual( c["out"].bound("/"), imath.Box3f(imath.V3f(0.5, -0.5, -0.5), imath.V3f(1.5, 0.5, 0.5))) self.assertEqual( c["out"].bound("/cube"), imath.Box3f(imath.V3f(-0.5, -0.5, -0.5), imath.V3f(0.5, 0.5, 0.5)))
def testTransform(self): p = GafferScene.Plane() p["transform"]["translate"].setValue(imath.V3f(1, 0, 0)) self.assertEqual(p["out"].transform("/"), imath.M44f()) self.assertEqual(p["out"].transform("/plane"), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual( p["out"].bound("/"), imath.Box3f(imath.V3f(0.5, -0.5, 0), imath.V3f(1.5, 0.5, 0))) self.assertEqual( p["out"].bound("/plane"), imath.Box3f(imath.V3f(-0.5, -0.5, 0), imath.V3f(0.5, 0.5, 0)))
def testLoadCobWithTransform(self): c = IECoreScene.CoordinateSystem( "test", IECoreScene.MatrixTransform(imath.M44f())) IECore.ObjectWriter(c, "test/IECore/data/coordSys.cob").write() c = IECore.ObjectReader("test/IECore/data/coordSys.cob").read() self.assertEqual(c.getTransform(), IECoreScene.MatrixTransform(imath.M44f())) c = IECoreScene.CoordinateSystem("test", None) IECore.ObjectWriter(c, "test/IECore/data/coordSys.cob").write() c = IECore.ObjectReader("test/IECore/data/coordSys.cob").read() self.assertEqual(c.getTransform(), None)
def testTransformsInImmediateRenderer( self ): r = IECoreGL.Renderer() r.setOption( "gl:mode", IECore.StringData( "immediate" ) ) r.transformBegin() r.concatTransform( imath.M44f().rotate( imath.V3f( 1, 1, 1 ) ) ) r.camera( "main", { "resolution" : IECore.V2iData( imath.V2i( 512 ) ), "projection" : IECore.StringData( "perspective" ) } ) r.transformEnd() r.worldBegin() # confirm that the camera transformation is not affecting the world space matrix r.concatTransform( imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) self.assertTrue( r.getTransform().equalWithAbsError( imath.M44f().translate( imath.V3f( 1, 0, 0 ) ), 1e-4 ) ) # confirm that setting the world space transform does not affect the camera matrix (that was already set in openGL ) r.setTransform( imath.M44f().translate( imath.V3f( 0, 1, 0 ) ) ) self.assertTrue( r.getTransform().equalWithAbsError( imath.M44f().translate( imath.V3f( 0, 1, 0 ) ), 1e-4 ) ) r.worldEnd()
def testCameraTransform( self ) : # camera must be output with an identity transform, because of the hierarchical # nature of this class... scene = IECoreMaya.LiveScene() cameraTransform = scene.child( "persp" ) maya.cmds.currentTime( "0.0sec" ) camera = cameraTransform.readObject( 0 ) # sanity check: camera transform is not identity? self.assertNotEqual( cameraTransform.readTransformAsMatrix( 0 ), imath.M44f() ) # this transform must be identity... self.assertEqual( camera.getTransform().transform(), imath.M44f() )
def testM44fPlugs(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["i"] = Gaffer.M44fPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["o"] = Gaffer.M44fPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["e"] = Gaffer.Expression() s["e"].setExpression("parent.n.user.o = parent.n.user.i * 2;", "OSL") s["n"]["user"]["i"].setValue(imath.M44f(*range(16))) self.assertEqual(s["n"]["user"]["o"].getValue(), imath.M44f(*range(0, 32, 2)))
def testPivotExpression(self): script = Gaffer.ScriptNode() script["plane"] = GafferScene.Plane() script["expression"] = Gaffer.Expression() script["expression"].setExpression( inspect.cleandoc(""" parent["plane"]["transform"]["pivot"]["x"] = context["x"] """)) script["variables"] = Gaffer.ContextVariables() script["variables"].setup(GafferScene.ScenePlug()) script["variables"]["in"].setInput(script["plane"]["out"]) script["variables"]["variables"].addChild( Gaffer.NameValuePlug("x", 1.0)) view = GafferSceneUI.SceneView() view["in"].setInput(script["variables"]["out"]) view.setContext(script.context()) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/plane"])) tool = GafferSceneUI.TranslateTool(view) tool["active"].setValue(True) self.assertEqual(tool.selection()[0].path, "/plane") self.assertEqual(tool.handlesTransform(), imath.M44f().translate(imath.V3f(1, 0, 0)))
def testRelativeTransform(self): plane1 = GafferScene.Plane() plane1["transform"]["translate"].setValue(imath.V3f(1, 2, 3)) plane1["transform"]["rotate"].setValue(imath.V3f(0, 90, 0)) plane1["name"].setValue("target") plane2 = GafferScene.Plane() plane2["name"].setValue("constrained") group = GafferScene.Group() group["in"][0].setInput(plane1["out"]) group["in"][1].setInput(plane2["out"]) self.assertSceneValid(group["out"]) constraint = GafferScene.ParentConstraint() constraint["target"].setValue("/group/target") constraint["in"].setInput(group["out"]) constraint["relativeTransform"]["translate"].setValue( imath.V3f(1, 0, 0)) filter = GafferScene.PathFilter() filter["paths"].setValue( IECore.StringVectorData(["/group/constrained"])) constraint["filter"].setInput(filter["out"]) self.assertSceneValid(constraint["out"]) self.assertEqual( constraint["out"].fullTransform("/group/constrained"), imath.M44f().translate(imath.V3f(1, 0, 0)) * group["out"].fullTransform("/group/target"))
def testDataTypes(self): d = IECore.CompoundData() d['a'] = IECore.IntData(1) d['c'] = IECore.FloatData(3) d['e'] = IECore.HalfData(4) d['f'] = IECore.V2iData(imath.V2i(1, 10)) d['g'] = IECore.V2fData(imath.V2f(2, 31), IECore.GeometricData.Interpretation.Vector) d['h'] = IECore.V2dData(imath.V2d(3, 551), IECore.GeometricData.Interpretation.Color) d['i'] = IECore.V3fData(imath.V3f(1, 3, 5), IECore.GeometricData.Interpretation.Point) d['k'] = IECore.M44fData(imath.M44f(2)) d['l'] = IECore.HalfVectorData([1, 2, 3, 100, 9, 10, 11]) d['m'] = IECore.V2fVectorData( [imath.V2f(1, 2), imath.V2f(3, 4), imath.V2f(5, 6)], IECore.GeometricData.Interpretation.Normal) d['x'] = IECore.StringData("testttt") d['z'] = IECore.StringVectorData(["a", 'b', 'adffs']) iface = IECore.IndexedIO.create("test/o.fio", [], IECore.IndexedIO.OpenMode.Write) d.save(iface, "test") dd = IECore.Object.load(iface, "test") self.assertEqual(d, dd)
def testInvalidRoot(self): p = GafferScene.Plane() p["sets"].setValue("A") g = GafferScene.Group() g["in"][0].setInput(p["out"]) s = GafferScene.SubTree() s["in"].setInput(g["out"]) # An invalid root matches nothing, so should output an empty scene for includeRoot in (True, False): s["includeRoot"].setValue(includeRoot) for root in ("notAThing", "/group/stillNotAThing", "/group/definitely/not/a/thing"): s["root"].setValue(root) self.assertSceneValid(s["out"]) self.assertEqual(s["out"].childNames("/"), IECore.InternedStringVectorData()) self.assertEqual(s["out"].set("A"), IECore.PathMatcherData()) self.assertEqual(s["out"].bound("/"), imath.Box3f()) self.assertEqual(s["out"].attributes("/"), IECore.CompoundObject()) self.assertEqual(s["out"].transform("/"), imath.M44f())
def testTransforms(self): def add(parent, child, vec): child.setTransform( IECoreScene.MatrixTransform(imath.M44f().translate(vec))) parent.addChild(child) if random.random() > 0.75: child.addChild(self.mesh()) group = IECoreScene.Group() group.setTransform( IECoreScene.MatrixTransform(imath.M44f().translate( imath.V3f(5, 0, 0)))) for i in range(0, 50): add( group, self.meshGroup(), imath.V3f(random.random(), random.random(), random.random()) * 3) null = self.emptySop() self.failUnless( IECoreHoudini.ToHoudiniGroupConverter(group).convert(null)) houdiniBound = null.geometry().boundingBox() bound = imath.Box3f(imath.V3f(list(houdiniBound.minvec())), imath.V3f(list(houdiniBound.maxvec()))) self.assertEqual(group.bound(), bound)