def testBound(self): fileName = "{}/testUSDBounds.scc".format(self.temporaryDirectory()) self._writeScene(fileName) # root stage = pxr.Usd.Stage.Open(fileName) root = stage.GetPseudoRoot() prim = root.GetPrimAtPath("/t/s") extent = prim.GetAttribute("extent") self.assertEqual( extent.Get(24.0), pxr.Vt.Vec3fArray(2, [pxr.Gf.Vec3f(0, 0, 0), pxr.Gf.Vec3f(1, 1, 1)])) self.assertEqual( extent.Get(48.0), pxr.Vt.Vec3fArray(2, [pxr.Gf.Vec3f(1, 1, 1), pxr.Gf.Vec3f(2, 2, 2)])) # round trip exportPath = "{}/testUSDExportBounds.scc".format( self.temporaryDirectory()) stage.Export(exportPath) scene = IECoreScene.SharedSceneInterfaces.get(exportPath) location = scene.scene(["t", "s"]) self.assertEqual(location.readBound(1), imath.Box3d(imath.V3d(0), imath.V3d(1))) self.assertEqual(location.readBound(2), imath.Box3d(imath.V3d(1), imath.V3d(2)))
def testAnimatedTransform( self ) : sphere = maya.cmds.polySphere( name="pSphere1" ) maya.cmds.setKeyframe( "pSphere1", attribute="tx", t="0sec", v=1 ) maya.cmds.setKeyframe( "pSphere1", attribute="ty", t="0sec", v=2 ) maya.cmds.setKeyframe( "pSphere1", attribute="tz", t="0sec", v=3 ) maya.cmds.setKeyframe( "pSphere1", attribute="tx", t="1sec", v=4 ) maya.cmds.setKeyframe( "pSphere1", attribute="ty", t="1sec", v=5 ) maya.cmds.setKeyframe( "pSphere1", attribute="tz", t="1sec", v=6 ) scene = IECoreMaya.LiveScene() transformChild = scene.child( "pSphere1" ) # test it returns the correct transform in local space maya.cmds.currentTime( "0sec" ) transform0 = transformChild.readTransform( 0 ).value maya.cmds.currentTime( "0.5sec" ) transform0_5 = transformChild.readTransform( 0.5 ).value maya.cmds.currentTime( "1sec" ) transform1 = transformChild.readTransform( 1 ).value self.assertEqual( transform0.translate, imath.V3d( 1, 2, 3 ) ) self.assertAlmostEqual( transform0_5.translate.x, 2.5, 5 ) self.assertAlmostEqual( transform0_5.translate.y, 3.5, 5 ) self.assertAlmostEqual( transform0_5.translate.z, 4.5, 5 ) self.assertEqual( transform1.translate, imath.V3d( 4, 5, 6 ) )
def testTransform(self): """Test TransformationMatrixd transform""" a = IECore.TransformationMatrixd() a.scale = imath.V3d( 2, 2, 2 ) self.assertEqual( a.transform, imath.M44d().scale( imath.V3d( 2, 2, 2 ) ) ) a.rotate = imath.Eulerd( 0.2, 0.2, 0.2 ) self.assertTrue( a.transform.equalWithAbsError( imath.M44d().scale( imath.V3d( 2, 2, 2 ) ) * imath.Eulerd( 0.2, 0.2, 0.2 ).toMatrix44(), 0.01 ) )
def testTransform( self ): fileName = "{}/testUSDTranform.scc".format( self.temporaryDirectory() ) m = IECoreScene.SceneCache( fileName, IECore.IndexedIO.OpenMode.Write ) t = m.createChild( "t" ) transformA = imath.V3d( 1, 0, 0 ) transformB = imath.V3d( 2, 0, 0 ) t.writeTransform( IECore.M44dData( imath.M44d().translate( transformA ) ), 1.0 ) t.writeTransform( IECore.M44dData( imath.M44d().translate( transformB ) ), 2.0 ) del m, t # root stage = pxr.Usd.Stage.Open( fileName ) root = stage.GetPseudoRoot() prim = root.GetPrimAtPath( "/{}/t".format( IECoreUSD.SceneCacheDataAlgo.internalRootName() ) ) transform = prim.GetAttribute( "xformOp:transform" ) self.assertEqual( transform.Get( 24.0 ), pxr.Gf.Matrix4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0 ) ) self.assertEqual( transform.Get( 48.0 ), pxr.Gf.Matrix4d(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 2.0, 0.0, 0.0, 1.0 ) ) # round trip exportPath = "{}/testUSDExportTransform.scc".format( self.temporaryDirectory() ) stage.Export( exportPath ) scene = IECoreScene.SharedSceneInterfaces.get( exportPath ) t = scene.child( "t" ) self.assertEqual( t.readTransformAsMatrix( 1 ).translation(), transformA ) self.assertEqual( t.readTransformAsMatrix( 2 ).translation(), transformB )
def makeRandomBound(self): b1 = imath.V3d(random.random(), random.random(), random.random()) b2 = imath.V3d(random.random(), random.random(), random.random()) bound = imath.Box3d(b1) bound.extendBy(b2) return bound
def testVectorLinearInterpolation(self): self.assertEqual( IECore.linearObjectInterpolation(IECore.IntVectorData([1]), IECore.IntVectorData([2]), 0.5), None) self.assertEqual( IECore.linearObjectInterpolation(IECore.FloatVectorData([1]), IECore.FloatVectorData([2]), 0.5), IECore.FloatVectorData([1.5])) self.assertEqual( IECore.linearObjectInterpolation(IECore.DoubleVectorData([1]), IECore.DoubleVectorData([2]), 0.5), IECore.DoubleVectorData([1.5])) self.assertEqual( IECore.linearObjectInterpolation( IECore.V2fVectorData([imath.V2f(1)]), IECore.V2fVectorData([imath.V2f(2)]), 0.5), IECore.V2fVectorData([imath.V2f(1.5)])) self.assertEqual( IECore.linearObjectInterpolation( IECore.V3fVectorData([imath.V3f(1)]), IECore.V3fVectorData([imath.V3f(2)]), 0.5), IECore.V3fVectorData([imath.V3f(1.5)])) self.assertEqual( IECore.linearObjectInterpolation( IECore.V2dVectorData([imath.V2d(1)]), IECore.V2dVectorData([imath.V2d(2)]), 0.5), IECore.V2dVectorData([imath.V2d(1.5)])) self.assertEqual( IECore.linearObjectInterpolation( IECore.V3dVectorData([imath.V3d(1)]), IECore.V3dVectorData([imath.V3d(2)]), 0.5), IECore.V3dVectorData([imath.V3d(1.5)]))
def testConcave( self ) : verticesPerFace = IECore.IntVectorData() verticesPerFace.append( 4 ) vertexIds = IECore.IntVectorData() vertexIds.append( 0 ) vertexIds.append( 1 ) vertexIds.append( 2 ) vertexIds.append( 3 ) P = IECore.V3dVectorData() P.append( imath.V3d( -1, 0, -1 ) ) P.append( imath.V3d( -1, 0, 1 ) ) P.append( imath.V3d( 1, 0, 1 ) ) P.append( imath.V3d( -0.9, 0, -0.9 ) ) m = IECoreScene.MeshPrimitive( verticesPerFace, vertexIds ) m["P"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, P ) def testTriangulate(): IECoreScene.MeshAlgo.triangulate( m, throwExceptions = True ) # Concave faces not supported by default self.assertRaises( RuntimeError, testTriangulate ) result = IECoreScene.MeshAlgo.triangulate( m )
def testConcave(self): """ Test TriangulateOp with a concave polygon""" verticesPerFace = IECore.IntVectorData() verticesPerFace.append(4) vertexIds = IECore.IntVectorData() vertexIds.append(0) vertexIds.append(1) vertexIds.append(2) vertexIds.append(3) P = IECore.V3dVectorData() P.append(imath.V3d(-1, 0, -1)) P.append(imath.V3d(-1, 0, 1)) P.append(imath.V3d(1, 0, 1)) P.append(imath.V3d(-0.9, 0, -0.9)) m = IECoreScene.MeshPrimitive(verticesPerFace, vertexIds) m["P"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, P) op = IECoreScene.TriangulateOp() op["input"] = m # Concave faces not supported by default self.assertRaises(RuntimeError, op) op.parameters()["throwExceptions"] = False result = op()
def testPerFrameWrite(self): fileName = "{}/testPerFrameWrite.scc".format(self.temporaryDirectory()) frames = list(range(1, 25)) for i in frames: stage = pxr.Usd.Stage.CreateInMemory() sphere = pxr.UsdGeom.Sphere.Define(stage, "/Sphere") attr = sphere.GetRadiusAttr() attr.Set(10, 1) attr.Set(100, 24) args = { "perFrameWrite": "1", "currentFrame": str(i), "firstFrame": str(frames[0]), "lastFrame": str(frames[-1]), } stage.Export(fileName, args=args) scene = IECoreScene.SharedSceneInterfaces.get(fileName) sphere = scene.child("Sphere") self.assertTrue(sphere) self.assertTrue( isinstance(sphere.readObject(0), IECoreScene.SpherePrimitive)) self.assertEqual(sphere.readBound(0), imath.Box3d(imath.V3d(-10), imath.V3d(10))) self.assertNotEqual(sphere.readBound(0.5), sphere.readBound(0)) self.assertEqual(sphere.readBound(1), imath.Box3d(imath.V3d(-100), imath.V3d(100)))
def testWriteAnimation(self): script = Gaffer.ScriptNode() script["sphere"] = GafferScene.Sphere() script["group"] = GafferScene.Group() script["group"]["in"][0].setInput(script["sphere"]["out"]) script["xExpression"] = Gaffer.Expression() script["xExpression"].setExpression( 'parent["group"]["transform"]["translate"]["x"] = context.getFrame()' ) script["zExpression"] = Gaffer.Expression() script["zExpression"].setExpression( 'parent["group"]["transform"]["translate"]["z"] = context.getFrame() * 2' ) script["writer"] = GafferScene.SceneWriter() script["writer"]["in"].setInput(script["group"]["out"]) script["writer"]["fileName"].setValue(self.temporaryDirectory() + "/test.scc") with Gaffer.Context(): script["writer"].executeSequence([1, 1.5, 2]) sc = IECoreScene.SceneCache(self.temporaryDirectory() + "/test.scc", IECore.IndexedIO.OpenMode.Read) t = sc.child("group") self.assertEqual(t.readTransformAsMatrix(0), imath.M44d().translate(imath.V3d(1, 0, 2))) self.assertEqual(t.readTransformAsMatrix(1 / 24.0), imath.M44d().translate(imath.V3d(1, 0, 2))) self.assertEqual(t.readTransformAsMatrix(1.5 / 24.0), imath.M44d().translate(imath.V3d(1.5, 0, 3))) self.assertEqual(t.readTransformAsMatrix(2 / 24.0), imath.M44d().translate(imath.V3d(2, 0, 4)))
def setUp(self): scene = IECoreScene.SceneCache(FnSceneShapeTest.__testFile, IECore.IndexedIO.OpenMode.Write) sc = scene.createChild(str(1)) mesh = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData([imath.V3f(1, 0, 0)] * 6)) sc.writeObject(mesh, 0.0) matrix = imath.M44d().translate(imath.V3d(1, 0, 0)) sc.writeTransform(IECore.M44dData(matrix), 0.0) sc = sc.createChild("child") mesh = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData([imath.V3f(0, 1, 0)] * 6)) sc.writeObject(mesh, 0.0) matrix = imath.M44d().translate(imath.V3d(2, 0, 0)) sc.writeTransform(IECore.M44dData(matrix), 0.0) sc = sc.createChild(str(3)) mesh = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData([imath.V3f(0, 0, 1)] * 6)) sc.writeObject(mesh, 0.0) matrix = imath.M44d().translate(imath.V3d(3, 0, 0)) sc.writeTransform(IECore.M44dData(matrix), 0.0) return scene
def _get_bounds(self): #TODO: ugly code needs refactor if self.state.scenes: bounds = None for scene in self.state.scenes: if not scene.loaded: continue if bounds is None or scene.bounds().max() > bounds.max(): bounds = scene.bounds() min = bounds.min() max = bounds.max() if scene.properties.get("translate"): max = max * imath.V3d(*scene.translate) min = min * imath.V3d(*scene.translate) if scene.properties.get("scale"): max = max * imath.V3d(*scene.scale) min = min * imath.V3d(*scene.scale) bounds = imath.Box3d(min, max) if bounds is None: return self.__bounds_default self.__bounds = bounds return self.__bounds else: return self.__bounds_default
def writeAnimatedSCC( self ) : scene = IECoreScene.SceneCache( self.__testFile, IECore.IndexedIO.OpenMode.Write ) time = 0 sc1 = scene.createChild( str( 1 ) ) mesh = IECoreScene.MeshPrimitive.createBox(imath.Box3f(imath.V3f(0),imath.V3f(1))) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ imath.V3f( 1, 0, 0 ) ] * 6 ) ) sc1.writeObject( mesh, time ) sc1.writeTransform( IECore.M44dData(), time ) sc2 = sc1.createChild( str( 2 ) ) mesh = IECoreScene.MeshPrimitive.createBox(imath.Box3f(imath.V3f(0),imath.V3f(1))) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ imath.V3f( 0, 1, 0 ) ] * 6 ) ) sc2.writeObject( mesh, time ) sc2.writeTransform( IECore.M44dData(), time ) sc3 = sc2.createChild( str( 3 ) ) mesh = IECoreScene.MeshPrimitive.createBox(imath.Box3f(imath.V3f(0),imath.V3f(1))) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ imath.V3f( 0, 0, 1 ) ] * 6 ) ) sc3.writeObject( mesh, time ) sc3.writeTransform( IECore.M44dData(), time ) for frame in [ 0.5, 1, 1.5, 2, 5, 10 ] : matrix = imath.M44d().translate( imath.V3d( 1, frame, 0 ) ) sc1.writeTransform( IECore.M44dData( matrix ), float( frame ) / 24 ) mesh["Cd"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ imath.V3f( frame, 1, 0 ) ] * 6 ) ) sc2.writeObject( mesh, float( frame ) / 24 ) matrix = imath.M44d().translate( imath.V3d( 2, frame, 0 ) ) sc2.writeTransform( IECore.M44dData( matrix ), float( frame ) / 24 ) matrix = imath.M44d().translate( imath.V3d( 3, frame, 0 ) ) sc3.writeTransform( IECore.M44dData( matrix ), float( frame ) / 24 )
def writeSCC(self, file, rotation=imath.V3d(0, 0, 0), time=0): scene = IECoreScene.SceneCache(file, IECore.IndexedIO.OpenMode.Write) sc = scene.createChild(str(1)) mesh = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))) sc.writeObject(mesh, time) matrix = imath.M44d().translate(imath.V3d(1, 0, 0)) matrix = matrix.rotate(rotation) sc.writeTransform(IECore.M44dData(matrix), time) sc = sc.createChild(str(2)) mesh = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))) sc.writeObject(mesh, time) matrix = imath.M44d().translate(imath.V3d(2, 0, 0)) matrix = matrix.rotate(rotation) sc.writeTransform(IECore.M44dData(matrix), time) sc = sc.createChild(str(3)) mesh = IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))) sc.writeObject(mesh, time) matrix = imath.M44d().translate(imath.V3d(3, 0, 0)) matrix = matrix.rotate(rotation) sc.writeTransform(IECore.M44dData(matrix), time) return scene
def mesh_out(name="cask_test_mesh.abc", force=False): filename = os.path.join(TEMPDIR, name) if not force and (os.path.exists(filename) and cask.is_valid(filename)): return filename oarch = alembic.Abc.OArchive(filename) meshyObj = alembic.AbcGeom.OPolyMesh(oarch.getTop(), 'meshy') mesh = meshyObj.getSchema() uvsamp = alembic.AbcGeom.OV2fGeomParamSample(meshData.uvs, kFacevaryingScope) nsamp = alembic.AbcGeom.ON3fGeomParamSample(meshData.normals, kFacevaryingScope) mesh_samp = alembic.AbcGeom.OPolyMeshSchemaSample(meshData.verts, meshData.indices, meshData.counts, uvsamp, nsamp) cbox = imath.Box3d() cbox.extendBy(imath.V3d(1.0, -1.0, 0.0)) cbox.extendBy(imath.V3d(-1.0, 1.0, 3.0)) for i in range(10): mesh.getChildBoundsProperty().setValue(cbox) mesh.set(mesh_samp) del oarch return filename
def testChildNamesHash(self): s = IECoreScene.SceneCache("/tmp/test.scc", IECore.IndexedIO.OpenMode.Write) sphereGroup = s.createChild("sphereGroup") sphereGroup.writeTransform( IECore.M44dData(imath.M44d().translate(imath.V3d(1, 0, 0))), 0.0) sphereGroup.writeTransform( IECore.M44dData(imath.M44d().translate(imath.V3d(2, 0, 0))), 1.0) sphere = sphereGroup.createChild("sphere") sphere.writeObject(IECoreScene.SpherePrimitive(), 0) del s, sphereGroup, sphere s = GafferScene.SceneReader() s["fileName"].setValue("/tmp/test.scc") s["refreshCount"].setValue( self.uniqueInt("/tmp/test.scc") ) # account for our changing of file contents between tests t = GafferScene.SceneTimeWarp() t["in"].setInput(s["out"]) t["offset"].setValue(1) self.assertSceneHashesEqual(s["out"], t["out"], childPlugNames=["childNames"])
def testTimeSetting( self ): fileName = "{}/testUSDTimeSettings.scc".format( self.temporaryDirectory() ) for sampleType in ( "transform", "attribute", "object" ): m = IECoreScene.SceneCache( fileName, IECore.IndexedIO.OpenMode.Write ) t = m.createChild( "t" ) if sampleType == "transform": t.writeTransform( IECore.M44dData(imath.M44d().translate(imath.V3d( 1, 0, 0 ))), 1.0 ) t.writeTransform( IECore.M44dData(imath.M44d().translate(imath.V3d( 2, 0, 0 ))), 2.0 ) elif sampleType == "attribute": t.writeAttribute( IECoreScene.SceneInterface.visibilityName, IECore.BoolData( True ), 1.0 ) t.writeAttribute( IECoreScene.SceneInterface.visibilityName, IECore.BoolData( False ), 2.0 ) else: boxA = IECoreScene.MeshPrimitive.createBox( imath.Box3f( imath.V3f( 0 ), imath.V3f( 1 ) ) ) t.writeObject( boxA, 1.0 ) boxB = IECoreScene.MeshPrimitive.createBox( imath.Box3f( imath.V3f( 1 ), imath.V3f( 2 ) ) ) t.writeObject( boxB, 2.0 ) del m, t # root stage = pxr.Usd.Stage.Open( fileName ) root = stage.GetPseudoRoot() metadata = root.GetAllMetadata() self.assertEqual( metadata["startTimeCode"], 24.0 ) self.assertEqual( metadata["endTimeCode"], 48.0 ) self.assertEqual( metadata["timeCodesPerSecond"], 24.0 )
def testConstructors(self): """Test TransformationMatrixd constructors""" a = IECore.TransformationMatrixd() self.assertEqual( a.transform, imath.M44d() ) a = IECore.TransformationMatrixd( imath.V3d( 2, 2, 2 ), imath.Eulerd(), imath.V3d( 1, 0, 0 ) ) self.assertTrue( a.transform.equalWithAbsError( imath.M44d().scale( imath.V3d(2,2,2) ) * imath.M44d().translate( imath.V3d(1,0,0) ), 0.01 ) ) b = IECore.TransformationMatrixd( a ) self.assertEqual( a.transform, b.transform )
def testConstructors(self): """Test TransformationMatrixdData constructors""" a = IECore.TransformationMatrixdData() self.assertEqual(a.value, IECore.TransformationMatrixd()) a = IECore.TransformationMatrixdData( IECore.TransformationMatrixd(imath.V3d(2, 2, 2), imath.Eulerd(), imath.V3d(1, 0, 0))) self.assertEqual(a.value.scale, imath.V3d(2, 2, 2))
def testBound( self ) : root = IECoreScene.SceneInterface.create( os.path.dirname( __file__ ) + "/data/cube.usda", IECore.IndexedIO.OpenMode.Read ) cube = root.child( "pCube1" ) bound = cube.readBound( 0.0 ) self.assertEqual( bound, imath.Box3d( imath.V3d( -0.5 ), imath.V3d( 0.5 ) ) )
def testCopy(self): """Test TransformationMatrixdData copy""" a = IECore.TransformationMatrixdData( IECore.TransformationMatrixd( imath.V3d( 2, 2, 2 ), imath.Eulerd(), imath.V3d( 1, 0, 0 ) ) ) self.assertEqual( a.value.scale, imath.V3d( 2, 2, 2 ) ) b = a.copy() a.value = IECore.TransformationMatrixd() self.assertEqual( b.value.scale, imath.V3d( 2, 2, 2 ) ) self.assertEqual( a.value.scale, imath.V3d( 1, 1, 1 ) )
def testSceneCacheRoundtrip(self): scene = IECoreScene.SceneCache( self.temporaryDirectory() + "/fromPython.scc", IECore.IndexedIO.OpenMode.Write) sc = scene.createChild("a") sc.writeObject( IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))), 0) matrix = imath.M44d().translate(imath.V3d(1, 0, 0)).rotate( imath.V3d(0, 0, IECore.degreesToRadians(-30))) sc.writeTransform(IECore.M44dData(matrix), 0) sc = sc.createChild("b") sc.writeObject( IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))), 0) sc.writeTransform(IECore.M44dData(matrix), 0) sc = sc.createChild("c") sc.writeObject( IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(0), imath.V3f(1))), 0) sc.writeTransform(IECore.M44dData(matrix), 0) del scene, sc def testCacheFile(f): sc = IECoreScene.SceneCache(f, IECore.IndexedIO.OpenMode.Read) a = sc.child("a") self.assertTrue(a.hasObject()) self.assertIsInstance(a.readObject(0), IECoreScene.MeshPrimitive) self.assertTrue( a.readTransformAsMatrix(0).equalWithAbsError(matrix, 1e-6)) b = a.child("b") self.assertTrue(b.hasObject()) self.assertIsInstance(b.readObject(0), IECoreScene.MeshPrimitive) self.assertTrue( b.readTransformAsMatrix(0).equalWithAbsError(matrix, 1e-6)) c = b.child("c") self.assertTrue(c.hasObject()) self.assertIsInstance(c.readObject(0), IECoreScene.MeshPrimitive) self.assertTrue( c.readTransformAsMatrix(0).equalWithAbsError(matrix, 1e-6)) testCacheFile(self.temporaryDirectory() + "/fromPython.scc") reader = GafferScene.SceneReader() reader["fileName"].setValue(self.temporaryDirectory() + "/fromPython.scc") script = Gaffer.ScriptNode() writer = GafferScene.SceneWriter() script["writer"] = writer writer["in"].setInput(reader["out"]) writer["fileName"].setValue(self.temporaryDirectory() + "/test.scc") writer.execute() os.remove(self.temporaryDirectory() + "/fromPython.scc") testCacheFile(self.temporaryDirectory() + "/test.scc")
def testComparison(self): """Test TransformationMatrixdData comparison""" a = IECore.TransformationMatrixdData() b = IECore.TransformationMatrixdData() self.assertEqual( a, b ) b.value = IECore.TransformationMatrixd( imath.V3d( 0.00001, 0, 0 ), imath.Eulerd(), imath.V3d(0,0,0) ) self.assertNotEqual( a, b ) a.value = IECore.TransformationMatrixd( imath.V3d( 0.00001, 0, 0 ), imath.Eulerd(), imath.V3d(0,0,0) ) self.assertEqual( a, b )
def testComparison(self): """Test TransformationMatrixd comparison""" a = IECore.TransformationMatrixd() b = IECore.TransformationMatrixd() self.assertEqual(a, b) b.scalePivot = imath.V3d(0.00001, 0, 0) self.assertNotEqual(a, b) a.scalePivot = imath.V3d(0.00001, 0, 0) self.assertEqual(a, b)
def testReadBound( self ) : scene = self.buildScene() hou.node( "/obj/sub1" ).parmTuple( "t" ).set( [ 1, 1, 1 ] ) hou.node( "/obj/sub1/torus1" ).parmTuple( "t" ).set( [ 2, 2, 2 ] ) hou.node( "/obj/sub1/torus2" ).parmTuple( "t" ).set( [ -1, 0, 2 ] ) hou.node( "/obj/box1" ).parmTuple( "t" ).set( [ -1, -1, -1 ] ) # to make the bounds nice round numbers hou.node( "/obj/sub1/torus1/actualTorus" ).parm( "rows" ).set( 100 ) hou.node( "/obj/sub1/torus1/actualTorus" ).parm( "cols" ).set( 100 ) hou.node( "/obj/sub1/torus2/actualTorus" ).parm( "rows" ).set( 100 ) hou.node( "/obj/sub1/torus2/actualTorus" ).parm( "cols" ).set( 100 ) self.assertEqual( scene.child( "box2" ).readBound( 0 ), imath.Box3d( imath.V3d( -0.5 ), imath.V3d( 0.5 ) ) ) sub1 = scene.child( "sub1" ) box1 = sub1.child( "box1" ) self.assertEqual( box1.readBound( 0 ), imath.Box3d( imath.V3d( -0.5 ), imath.V3d( 0.5 ) ) ) torus1 = sub1.child( "torus1" ) torus2 = torus1.child( "torus2" ) self.assertEqual( torus2.readBound( 0 ), imath.Box3d( imath.V3d( -1.5, -0.5, -1.5 ), imath.V3d( 1.5, 0.5, 1.5 ) ) ) self.assertEqual( torus1.readBound( 0 ), imath.Box3d( imath.V3d( -2.5, -0.5, -1.5 ), imath.V3d( 1.5, 0.5, 3.5 ) ) ) self.assertEqual( sub1.readBound( 0 ), imath.Box3d( imath.V3d( -1.5 ), imath.V3d( 3.5, 2.5, 5.5 ) ) ) self.assertEqual( scene.readBound( 0 ), imath.Box3d( imath.V3d( -0.5 ), imath.V3d( 4.5, 3.5, 6.5 ) ) )
def testIO(self): """Test TransformationMatrixdData IO""" a = IECore.TransformationMatrixdData( IECore.TransformationMatrixd(imath.V3d(2, 3, 4), imath.Eulerd(), imath.V3d(1, 2, 3))) w = IECore.ObjectWriter(a, self.testFile) w.write() r = IECore.ObjectReader(self.testFile) b = r.read() self.assertEqual(a, b)
def testBound(self): a = IECoreScene.SceneInterface.create( os.path.dirname(__file__) + "/data/cube.abc", IECore.IndexedIO.OpenMode.Read) self.assertEqual(a.readBoundAtSample(0), imath.Box3d(imath.V3d(-2), imath.V3d(2))) cs = a.child("group1").child("pCube1") self.assertEqual(cs.readBoundAtSample(0), imath.Box3d(imath.V3d(-1), imath.V3d(1)))
def testCanReadBounds(self): bound = self.sceneInterface.readBound(0.0) expectedBound = imath.Box3d( imath.V3d([ -33.809524536132812, -12.380952835083008, -26.190475463867188 ]), imath.V3d( [19.047618865966797, 93.333335876464844, 27.142856597900391])) self.assertEqual(bound, expectedBound)
def test_child_bounds(self): filename_1 = os.path.join(TEMPDIR, "cask_child_bounds_1.abc") filename_2 = os.path.join(TEMPDIR, "cask_child_bounds_2.abc") filename_3 = os.path.join(TEMPDIR, "cask_child_bounds_3.abc") # create initial archive with initial value bounds = imath.Box3d( imath.V3d(1, 1, 1), imath.V3d(1, 1, 1) ) a = cask.Archive() x = a.top.children["foo"] = cask.Xform() p = x.properties[".xform/.childBnds"] = cask.Property() p.set_value(bounds) self.assertEqual(p.values[0], bounds) a.write_to_file(filename_1) a.close() # verify export / value b = cask.Archive(filename_1) p = b.top.children["foo"].properties[".xform/.childBnds"] self.assertEqual(len(p.values), 1) self.assertEqual(p.values[0], bounds) self.assertEqual(p.metadata.get("interpretation"), "box") # set a new child bounds value and export bounds = imath.Box3d( imath.V3d(-5, -5, -5), imath.V3d(5, 5, 5) ) p.values[0] = bounds self.assertEqual(p.values[0], bounds) b.write_to_file(filename_2) b.close() # verify the updated value in the export c = cask.Archive(filename_2) p = c.top.children["foo"].properties[".xform/.childBnds"] self.assertEqual(len(p.values), 1) self.assertEqual(p.values[0], bounds) self.assertEqual(p.metadata.get("interpretation"), "box") # reinitialize the property and export p = c.top.children["foo"].properties[".xform/.childBnds"] = cask.Property() p.set_value(bounds) c.write_to_file(filename_3) c.close() # re-verify the updated value in the export d = cask.Archive(filename_3) p = d.top.children["foo"].properties[".xform/.childBnds"] self.assertEqual(len(p.values), 1) self.assertEqual(p.values[0], bounds) self.assertEqual(p.metadata.get("interpretation"), "box")
def testStructureConvertion(self): self.assertEqual( IECore.DataCastOp()(object=IECore.V3fData(imath.V3f(1, 2, 3)), targetType=int(IECore.TypeId.FloatVectorData)), IECore.FloatVectorData([1, 2, 3])) self.assertEqual( IECore.DataCastOp()(object=IECore.V3fData(imath.V3f(1, 2, 3)), targetType=int(IECore.TypeId.Color3fData)), IECore.Color3fData(imath.Color3f(1, 2, 3))) self.assertEqual( IECore.DataCastOp()(object=IECore.V3fVectorData( [imath.V3f(1), imath.V3f(2), imath.V3f(3)]), targetType=int(IECore.TypeId.FloatVectorData)), IECore.FloatVectorData([1, 1, 1, 2, 2, 2, 3, 3, 3])) self.assertEqual( IECore.DataCastOp()(object=IECore.FloatVectorData([1, 2, 3]), targetType=int(IECore.TypeId.V3fData)), IECore.V3fData(imath.V3f(1, 2, 3))) self.assertEqual( IECore.DataCastOp()(object=IECore.Color3fData( imath.Color3f(1, 2, 3)), targetType=int(IECore.TypeId.V3fData)), IECore.V3fData(imath.V3f(1, 2, 3))) self.assertEqual( IECore.DataCastOp()(object=IECore.FloatVectorData( [1, 1, 1, 2, 2, 2, 3, 3, 3]), targetType=int(IECore.TypeId.V3fVectorData)), IECore.V3fVectorData([imath.V3f(1), imath.V3f(2), imath.V3f(3)])) self.assertEqual( IECore.DataCastOp()(object=IECore.V3fVectorData( [imath.V3f(1), imath.V3f(2), imath.V3f(3)]), targetType=int( IECore.TypeId.Color3fVectorData)), IECore.Color3fVectorData( [imath.Color3f(1), imath.Color3f(2), imath.Color3f(3)])) self.assertEqual( IECore.DataCastOp()(object=IECore.V3dVectorData( [imath.V3d(1), imath.V3d(2), imath.V3d(3)]), targetType=int( IECore.TypeId.Color3fVectorData)), IECore.Color3fVectorData( [imath.Color3f(1), imath.Color3f(2), imath.Color3f(3)]))