def test_Basic(self): # Test CopyLayerMetadata() source = Sdf.Layer.FindOrOpen('layerWithMetadata.usda') self.assertTrue(source) keysToCompare = [ x for x in source.pseudoRoot.ListInfoKeys() if (x not in ['subLayers', 'subLayerOffsets']) ] cpy = Sdf.Layer.CreateNew("cpy.usda") self.assertTrue(cpy) UsdUtils.CopyLayerMetadata(source, cpy) for key in ['subLayers'] + keysToCompare: self.assertEqual(source.pseudoRoot.GetInfo(key), cpy.pseudoRoot.GetInfo(key)) # bug #127687 - can't use GetInfo() for subLayerOffsets self.assertEqual(source.subLayerOffsets, cpy.subLayerOffsets) cpyNoSublayers = Sdf.Layer.CreateNew("cpyNoSublayers.usda") self.assertTrue(cpyNoSublayers) UsdUtils.CopyLayerMetadata(source, cpyNoSublayers, skipSublayers=True) self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayers')) self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayerOffsets')) for key in keysToCompare: self.assertEqual(source.pseudoRoot.GetInfo(key), cpyNoSublayers.pseudoRoot.GetInfo(key))
def setUp(self): self.layers = [ Sdf.Layer.CreateAnonymous(), Sdf.Layer.FindOrOpen('src/Particles_Splash.101.usd'), Sdf.Layer.FindOrOpen('src/Particles_Splash.103.usd'), Sdf.Layer.CreateAnonymous(), Sdf.Layer.FindOrOpen('src/letters_perFrame.101.usda'), Sdf.Layer.FindOrOpen('src/letters_perFrame.102.usda'), Sdf.Layer.FindOrOpen('src/letters_perFrame.103.usda') ] self.rootprims_combined = None self.rootprims_a = None self.rootprims_b = None # stitch layers for basic tests UsdUtils.StitchLayers(self.layers[0], self.layers[1]) UsdUtils.StitchLayers(self.layers[0], self.layers[2]) self.rootprims_combined = self.layers[0].rootPrims self.rootprims_a = self.layers[1].rootPrims self.rootprims_b = self.layers[2].rootPrims # stitch layers for secondary tests UsdUtils.StitchLayers(self.layers[3], self.layers[4]) UsdUtils.StitchLayers(self.layers[3], self.layers[5]) UsdUtils.StitchLayers(self.layers[3], self.layers[6])
def test_Basic(self): # Test CopyLayerMetadata() source = Sdf.Layer.FindOrOpen('layerWithMetadata.usda') self.assertTrue(source) keysToCompare = [x for x in source.pseudoRoot.ListInfoKeys() if (x not in ['subLayers', 'subLayerOffsets'])] cpy = Sdf.Layer.CreateNew("cpy.usda") self.assertTrue(cpy) UsdUtils.CopyLayerMetadata(source, cpy) for key in ['subLayers'] + keysToCompare: self.assertEqual(source.pseudoRoot.GetInfo(key), cpy.pseudoRoot.GetInfo(key)) # bug #127687 - can't use GetInfo() for subLayerOffsets self.assertEqual(source.subLayerOffsets, cpy.subLayerOffsets) cpyNoSublayers = Sdf.Layer.CreateNew("cpyNoSublayers.usda") self.assertTrue(cpyNoSublayers) UsdUtils.CopyLayerMetadata(source, cpyNoSublayers, skipSublayers=True, bakeUnauthoredFallbacks=True) self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayers')) self.assertFalse(cpyNoSublayers.pseudoRoot.HasInfo('subLayerOffsets')) for key in keysToCompare: self.assertEqual(source.pseudoRoot.GetInfo(key), cpyNoSublayers.pseudoRoot.GetInfo(key)) # Ensure that the color config fallbacks get stamped out when # bakeUnauthoredFallbacks is set to true. fallbackKeysToCompare = ['colorConfiguration', 'colorManagementSystem'] colorConfigFallbacks = Usd.Stage.GetColorConfigFallbacks() self.assertEqual(colorConfigFallbacks, (cpyNoSublayers.pseudoRoot.GetInfo(Sdf.Layer.ColorConfigurationKey), cpyNoSublayers.pseudoRoot.GetInfo(Sdf.Layer.ColorManagementSystemKey)))
def CheckCompliance(self, inputFile): from pxr import Sdf, Usd, UsdUtils if not Usd.Stage.IsSupportedFile(inputFile): _AddError("Cannot open file '%s' on a USD stage." % args.inputFile) return # Collect all warnings using a diagnostic delegate. delegate = UsdUtils.CoalescingDiagnosticDelegate() usdStage = Usd.Stage.Open(inputFile) stageOpenDiagnostics = delegate.TakeUncoalescedDiagnostics() for rule in self._rules: rule.CheckStage(usdStage) rule.CheckDiagnostics(stageOpenDiagnostics) with Ar.ResolverContextBinder(usdStage.GetPathResolverContext()): # This recursively computes all of inputFiles's external # dependencies. (allLayers, allAssets, unresolvedPaths) = \ UsdUtils.ComputeAllDependencies(Sdf.AssetPath(inputFile)) for rule in self._rules: rule.CheckUnresolvedPaths(unresolvedPaths) rule.CheckDependencies(usdStage, allLayers, allAssets) if self._rootPackageOnly: rootLayer = usdStage.GetRootLayer() if rootLayer.GetFileFormat().IsPackage(): packagePath = Ar.SplitPackageRelativePathInner( rootLayer.identifier)[0] self._CheckPackage(packagePath) else: self._AddError( "Root layer of the USD stage (%s) doesn't belong to " "a package, but 'rootPackageOnly' is True!" % Usd.Describe(usdStage)) else: # Process every package just once by storing them all in a set. packages = set() for layer in allLayers: if _IsPackageOrPackagedLayer(layer): packagePath = Ar.SplitPackageRelativePathInner( layer.identifier)[0] packages.add(packagePath) self._CheckLayer(layer) for package in packages: self._CheckPackage(package) # Traverse the entire stage and check every prim. from pxr import Usd # Author all variant switches in the session layer. usdStage.SetEditTarget(usdStage.GetSessionLayer()) allPrimsIt = iter( Usd.PrimRange.Stage(usdStage, Usd.TraverseInstanceProxies())) self._TraverseRange(allPrimsIt, isStageRoot=True)
def test_StitchTopologyOnly(self): # Generate a fresh topology topologyLayer = Sdf.Layer.CreateNew('topologyLayer.usd') UsdUtils.StitchClipsTopology(topologyLayer, self.layerFileNames[:7]) self.assertTrue(topologyLayer) self.assertTrue(topologyLayer.GetPrimAtPath(self.clipPath)) # Aggregate into an existing topology newClipPath = Sdf.Path('/World/fx/points') UsdUtils.StitchClipsTopology(topologyLayer, self.layerFileNames[8:10]) self.assertTrue(topologyLayer) self.assertTrue(topologyLayer.GetPrimAtPath(newClipPath))
def delegateSetup(stringIncFilders, codePathIncFilters, stringExcFilters, codePathExcFilters): incFilter = UsdUtils.ConditionalAbortDiagnosticDelegateErrorFilters() excFilter = UsdUtils.ConditionalAbortDiagnosticDelegateErrorFilters() if stringIncFilders: incFilter.SetStringFilters(stringIncFilders) if codePathIncFilters: incFilter.SetCodePathFilters(codePathIncFilters) if stringExcFilters: excFilter.SetStringFilters(stringExcFilters) if codePathExcFilters: excFilter.SetCodePathFilters(codePathExcFilters) return UsdUtils.ConditionalAbortDiagnosticDelegate(incFilter, excFilter)
def test_TopologySublayerAuthoring(self): resultLayer = Sdf.Layer.CreateNew('sublayerTopology.usd') UsdUtils.StitchClips(resultLayer, self.layerFileNames[:7], self.clipPath) self.assertEqual(list(resultLayer.subLayerPaths), ['./sublayerTopology.topology.usd']) resultLayer = Sdf.Layer.CreateNew('foo.usd') topLayer = Sdf.Layer.CreateNew('foo.topology.usd') UsdUtils.StitchClipsTemplate(resultLayer, topLayer, self.clipPath, 'asset.#.usd', 101, 120, 1) self.assertEqual(list(resultLayer.subLayerPaths), ['./foo.topology.usd'])
def check_usd_compliance(rootLayer, arkit=False): #An API change in v18.11 changed the sytax for UsdUtils.ComplianceChecker... if Usd.GetMinorVersion() >= 18 and Usd.GetPatchVersion() >= 11: checker = UsdUtils.ComplianceChecker(arkit=arkit, skipARKitRootLayerCheck=False) checker.CheckCompliance(rootLayer) else: #Behavior in v18.09 checker = UsdUtils.ComplianceChecker(rootLayer, arkit=arkit, skipARKitRootLayerCheck=False) errors = checker.GetErrors() failedChecks = checker.GetFailedChecks() for msg in errors + failedChecks: print(msg) return len(errors) == 0 and len(failedChecks) == 0
def test_Basic(self): lyr1 = Sdf.Layer.FindOrOpen('BottleMedicalDefaultPrim.usd') self.assertTrue(lyr1) self.assertEqual(UsdUtils.GetModelNameFromRootLayer(lyr1), 'BottleMedical') lyr2 = Sdf.Layer.FindOrOpen('BottleMedicalSameName.usd') self.assertTrue(lyr2) self.assertEqual(UsdUtils.GetModelNameFromRootLayer(lyr2), 'BottleMedicalSameName') lyr3 = Sdf.Layer.FindOrOpen('BottleMedicalRootPrim.usd') self.assertTrue(lyr3) self.assertEqual(UsdUtils.GetModelNameFromRootLayer(lyr3), 'BottleMedical')
def test_APISchemaGen(self): sdrNode = self._GetSdrNode("testSdrNodeAPISchema.usda", "/TestSchemaAPI") self.assertTrue(sdrNode) resultLayer = Sdf.Layer.CreateNew("./resultAPISchema.usda") UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode, "myRenderContext")
def PrintTree(args, path): if args.flatten: popMask = (None if args.populationMask is None else Usd.StagePopulationMask()) if popMask: for mask in args.populationMask: popMask.Add(mask) if popMask: if args.unloaded: stage = Usd.Stage.OpenMasked(path, popMask, Usd.Stage.LoadNone) else: stage = Usd.Stage.OpenMasked(path, popMask) else: if args.unloaded: stage = Usd.Stage.Open(path, Usd.Stage.LoadNone) else: stage = Usd.Stage.Open(path) PrintStage(args, stage) elif args.flattenLayerStack: from pxr import UsdUtils stage = Usd.Stage.Open(path, Usd.Stage.LoadNone) layer = UsdUtils.FlattenLayerStack(stage) PrintLayer(args, layer) else: from pxr import Sdf layer = Sdf.Layer.FindOrOpen(path) PrintLayer(args, layer)
def testCameraCmdlineArgs(self): """ Tests argument parsing when camera-related args are added. """ UsdAppUtils.cameraArgs.AddCmdlineArgs(self._parser) # By default, the camera arg should contain the primary camera name. args = self._parser.parse_args([]) self.assertEqual(type(args.camera), Sdf.Path) self.assertEqual(args.camera.pathString, UsdUtils.GetPrimaryCameraName()) args = self._parser.parse_args(['--camera', 'MainCamera']) self.assertEqual(type(args.camera), Sdf.Path) self.assertEqual(args.camera.pathString, 'MainCamera') args = self._parser.parse_args(['-cam', 'MainCamera']) self.assertEqual(type(args.camera), Sdf.Path) self.assertEqual(args.camera.pathString, 'MainCamera') args = self._parser.parse_args(['--camera', '/Path/To/Some/Camera']) self.assertEqual(type(args.camera), Sdf.Path) self.assertEqual(args.camera.pathString, '/Path/To/Some/Camera') args = self._parser.parse_args(['--camera', '']) self.assertEqual(type(args.camera), Sdf.Path) self.assertEqual(args.camera, Sdf.Path.emptyPath) # Test adding camera args with a different default value. parser = argparse.ArgumentParser(prog=self._progName) UsdAppUtils.cameraArgs.AddCmdlineArgs(parser, defaultValue='MainCamera') args = parser.parse_args([]) self.assertEqual(type(args.camera), Sdf.Path) self.assertEqual(args.camera.pathString, 'MainCamera')
def testSkelMissingJointFromDagPose(self): """ Check that dagPoses that don't contain all desired joints issue an appropriate warning """ mayaFile = os.path.join(self.inputPath, "UsdExportSkeletonTest", "UsdExportSkeletonBindPoseMissingJoints.ma") cmds.file(mayaFile, force=True, open=True) usdFile = os.path.abspath('UsdExportBindPoseMissingJointsTest.usda') joints = cmds.listRelatives('joint_grp', allDescendents=True, type='joint') bindMembers = cmds.dagPose('dagPose1', q=1, members=1) nonBindJoints = [j for j in joints if j not in bindMembers] self.assertEqual(nonBindJoints, [u'joint4']) delegate = UsdUtils.CoalescingDiagnosticDelegate() cmds.select('joint_grp') cmds.mayaUSDExport(mergeTransformAndShape=True, file=usdFile, shadingMode='none', exportSkels='auto', selection=True) messages = delegate.TakeUncoalescedDiagnostics() warnings = [x.commentary for x in messages if x.diagnosticCode == Tf.TF_DIAGNOSTIC_WARNING_TYPE] missingJointWarnings = [x for x in warnings if 'is not a member of dagPose' in x] self.assertEqual(len(missingJointWarnings), 1) self.assertIn("Node 'joint4' is not a member of dagPose 'dagPose1'", missingJointWarnings[0])
def dep(usdfile, level=1): id = '-' * (level) # print('UsdUtilsExtractExternalReferences'.center(40, '-')) print(id, usdfile) sublayers, references, payloads = UsdUtils.ExtractExternalReferences( usdfile) if sublayers: print(id, 'SUBLAYERS') for sublayer in sublayers: # print(id, sublayer) refpath = os.path.normpath( os.path.join(os.path.dirname(usdfile), sublayer)) dep(refpath, level=level + 1) if references: print(id, 'REFERENCES') for reference in references: # print(id, reference) refpath = os.path.normpath( os.path.join(os.path.dirname(usdfile), reference)) dep(refpath, level=level + 1) if payloads: print(id, 'PAYLOADS') for payload in payloads: # print(id, payload) refpath = os.path.normpath( os.path.join(os.path.dirname(usdfile), payload)) dep(refpath, level=level + 1)
def test_rmanConcreteSchema(self): sdrNode = self._GetSdrNode("testSdrNodeConcreteSchema.usda", "/TestSchemaConcrete") self.assertTrue(sdrNode) resultLayer = Sdf.Layer.CreateNew("./schemaConcrete.usda") UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode, "myRenderContext")
def test_OmitDuplicatePropertiesTypeMismatch(self): sdrNode = self._GetSdrNode("testDuplicatePropsTypeMismatch.usda", "/TestDuplicatePropsAPI") self.assertTrue(sdrNode) resultLayer = Sdf.Layer.CreateNew("./duplicatePropTypeMisMatch.usda") UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode, "myRenderContext")
def test_OverrideAPISchemaGen(self): sdrNode = self._GetSdrNode("testSdrNodeAPISchema.usda", "/TestSchemaAPI") self.assertTrue(sdrNode) resultLayer = Sdf.Layer.FindOrOpen("./result_override.usda") UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode, "myRenderContext")
def test_APIIdentifierMissing(self): sdrNode = self._GetSdrNode("testAPIIdentifierMissing.usda", "/APIIdentifierMissing") self.assertTrue(sdrNode) resultLayer = Sdf.Layer.CreateNew("./resultAPIIdentifierMissing.usda") UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode, "myRenderContext")
def GetFlattenedLayerStack(filePath): from pxr import Ar, Sdf, Pcp, Usd, UsdUtils if hasattr(Ar.Resolver, "ConfigureResolverForAsset"): Ar.GetResolver().ConfigureResolverForAsset(filePath) stage = Usd.Stage.Open(filePath, Usd.Stage.LoadNone) return UsdUtils.FlattenLayerStack(stage)
def setUp(self): if not hasattr(self, 'setupComplete'): self.layerFileNames = [ 'src/Particles_Splash.101.usd', 'src/Particles_Splash.102.usd', 'src/Particles_Splash.103.usd', 'src/Particles_Splash.104.usd', 'src/Particles_Splash.105.usd', 'src/Particles_Splash.106.usd', 'src/Particles_Splash.107.usd', 'src/Particles_Splash.108.usd', 'src/PTS_dev.1.usd', 'src/PTS_dev.2.usd', 'src/PTS_dev.3.usd', 'src/PTS_dev.4.usd', 'src/PTS_dev.5.usd', 'src/PTS_dev.6.usd', 'src/PTS_dev.7.usd', 'src/PTS_dev.8.usd', 'src/PTS_dev.9.usd', 'src/PTS_dev.10.usd', 'src/PTS_dev.11.usd', 'src/PTS_dev.12.usd', 'src/PTS_dev.13.usd', 'src/PTS_dev.14.usd', 'src/PTS_dev.15.usd', 'src/PTS_dev.16.usd', 'src/PTS_dev.17.usd', 'src/PTS_dev.18.usd', 'src/PTS_dev.19.usd', 'src/PTS_dev.20.usd', 'src/PTS_dev.21.usd', 'src/PTS_dev.22.usd', 'src/PTS_dev.23.usd', 'src/PTS_dev.24.usd' ] self.clipPath = Sdf.Path('/World/fx/Particles_Splash') self.baseName = 'testModelClips.usd' self.startTimeCode = 101 self.endTimeCode = 108 rootLayer = Sdf.Layer.FindOrOpen(self.baseName) self.rootLayer = rootLayer if rootLayer else Sdf.Layer.CreateNew( self.baseName) UsdUtils.StitchClips(self.rootLayer, self.layerFileNames[0:7], self.clipPath, self.startTimeCode, self.endTimeCode) self.setupComplete = True
def test_ClipAssetPaths(self): src_stage = Usd.Stage.Open('root.usda') def replaceWithFoo(layer, s): return 'foo' layer = UsdUtils.FlattenLayerStack(src_stage, resolveAssetPathFn=replaceWithFoo) result_stage = Usd.Stage.Open(layer) # Confirm offsets have been folded into value clips. p = layer.GetPrimAtPath('/SphereUsingClip') self.assertEqual( p.GetInfo('clips')['default']['active'], Vt.Vec2dArray(1, [(-9.0, 0)])) self.assertEqual( p.GetInfo('clips')['default']['times'], Vt.Vec2dArray(2, [(-9.0, 1), (0.0, 10)])) # And confirm clip asset paths have been updated. self.assertEqual( p.GetInfo('clips')['default']['manifestAssetPath'], Sdf.AssetPath('foo')) self.assertEqual(list(p.GetInfo('clips')['default']['assetPaths']), [Sdf.AssetPath('foo')])
def test_GenerateTopologyName(self): names = [("/foo/bar/baz.foo.usd", "/foo/bar/baz.foo.topology.usd"), ("foo.usda", "foo.topology.usda"), ("./mars.usd", "./mars.topology.usd")] for (original, expected) in names: self.assertEqual(UsdUtils.GenerateClipTopologyName(original), expected)
def test_ComputeAllDependenciesInvalidClipTemplate(self): """Test that an invalid clip template asset path does not cause an exception in UsdUtils.ComputeAllDependencies.""" stage = Usd.Stage.CreateNew('testInvalidClipTemplate.usda') prim = stage.DefinePrim('/clip') Usd.ClipsAPI(prim).SetClipTemplateAssetPath('bogus') stage.Save() UsdUtils.ComputeAllDependencies(stage.GetRootLayer().identifier)
def test_UsdShadeConnectableAPIMetadata2(self): sdrNode = self._GetSdrNode("testUsdShadeConnectableAPI2.usda", "/TestUsdShadeConnectableAPIMetadataAPI") self.assertTrue(sdrNode) resultLayer = \ Sdf.Layer.CreateNew("./resultUsdShadeConnectableAPIMetadata2.usda") UsdUtils.UpdateSchemaWithSdrNode(resultLayer, sdrNode, "myRenderContext")
def __init__(self, inputFile, arkit=False, skipARKitRootLayerCheck=False, rootPackageOnly=False, skipVariants=False, verbose=False): self._arkit = arkit self._skipARKitRootLayerCheck = skipARKitRootLayerCheck self._rootPackageOnly = rootPackageOnly self._doVariants = not skipVariants self._verbose = verbose self._failedChecks = [] self._errors = [] self._violatedRules = set() self._checkedPackages = set() from pxr import Ar, Sdf, Usd, UsdUtils if not Usd.Stage.IsSupportedFile(inputFile): _AddError("Cannot open file '%s' on a USD stage." % args.inputFile) return # Collect all warnings using a diagnostic delegate. delegate = UsdUtils.CoalescingDiagnosticDelegate() usdStage = Usd.Stage.Open(inputFile) allDiagnostics = delegate.TakeUncoalescedDiagnostics() if self._arkit: for diag in allDiagnostics: # "_ReportErrors" is the name of the function that issues # warnings about unresolved references, sublayers and other # composition arcs. if '_ReportErrors' in diag.sourceFunction and \ 'usd/stage.cpp' in diag.sourceFileName: self._AddFailedCheck(diag.commentary, ruleNum=4) with Ar.ResolverContextBinder(usdStage.GetPathResolverContext()): # This recursively computes all of inputFiles's external # dependencies. (allLayerDeps, allAssetDeps, unresolvedPaths) = \ UsdUtils.ComputeAllDependencies(Sdf.AssetPath(inputFile)) self._CheckDependencies(usdStage, allLayerDeps, allAssetDeps, unresolvedPaths) self._CheckStage(usdStage, allLayerDeps)
def test_ExplicitEndCodes(self): start = 104 end = 105 resultLayer = Sdf.Layer.CreateNew('explicitEndCodes.usd') UsdUtils.StitchClips(resultLayer, self.layerFileNames[:7], self.clipPath, start, end) self.assertEqual(resultLayer.startTimeCode, start) self.assertEqual(resultLayer.endTimeCode, end)
def convert_to_usd(gltf_file, usd_file, fps, scale, arkit=False, verbose=False, use_euler_rotation=False): """Converts a glTF file to USD Arguments: gltf_file {str} -- path to glTF file usd_file {str} -- path to write USD file Keyword Arguments: verbose {bool} -- [description] (default: {False}) """ usd = GLTF2USD(gltf_file=gltf_file, usd_file=usd_file, fps=fps, scale=scale, verbose=verbose, use_euler_rotation=use_euler_rotation) if usd.stage: asset = usd.stage.GetRootLayer() usd.logger.info('Conversion complete!') asset.Save() usd.logger.info('created {}'.format(asset.realPath)) if usd_file.endswith('.usdz') or usd_file.endswith('.usdc'): usdc_file = '%s.%s' % (os.path.splitext(usd_file)[0], 'usdc') asset.Export(usdc_file, args=dict(format='usdc')) usd.logger.info('created {}'.format(usdc_file)) if usd_file.endswith('.usdz'): r = Ar.GetResolver() resolved_asset = r.Resolve(usdc_file) context = r.CreateDefaultContextForAsset(resolved_asset) success = check_usd_compliance(resolved_asset, arkit=args.arkit) with Ar.ResolverContextBinder(context): if arkit and not success: usd.logger.warning('USD is not ARKit compliant') return success = UsdUtils.CreateNewUsdzPackage( resolved_asset, usd_file) and success if success: usd.logger.info( 'created package {} with contents:'.format(usd_file)) zip_file = Usd.ZipFile.Open(usd_file) file_names = zip_file.GetFileNames() for file_name in file_names: usd.logger.info('\t{}'.format(file_name)) else: usd.logger.error('could not create {}'.format(usd_file))
def check_usd_compliance(rootLayer, arkit=False): checker = UsdUtils.ComplianceChecker(rootLayer, arkit=arkit, skipARKitRootLayerCheck=False) errors = checker.GetErrors() failedChecks = checker.GetFailedChecks() for msg in errors + failedChecks: print(msg) return len(errors) == 0 and len(failedChecks) == 0
def test_NumericalPrecisionLoss(self): rootLayerFile = 'numericalPrecision.usd' clipPath = Sdf.Path("/World/fx/points") rootLayer = Sdf.Layer.CreateNew(rootLayerFile) UsdUtils.StitchClips(rootLayer, self.layerFileNames[8:], clipPath) self.assertTrue(rootLayer) self.assertEqual(rootLayer.startTimeCode, 1.00000) # previously, the precision error was causing # us to end up with an end frame of 24.0006 self.assertEqual(rootLayer.endTimeCode, 24.000000)
def GetUsdLayerMetaData(filePath): """Return an SdfLayer holding just the layer metadata of the given layer.""" from pxr import Sdf, UsdUtils srcLayer = Sdf.Layer.OpenAsAnonymous(filePath, metadataOnly=True) # Not all file format plugins support metadata-only parsing. # Create a new anonymous layer and copy just the layer metadata. layer = Sdf.Layer.CreateAnonymous(filePath, Sdf.FileFormat.FindById('usda')) UsdUtils.CopyLayerMetadata(srcLayer, layer) return layer