def bs_sanityCheckNamespaces():
"""
@ get all namespaces in the scene.
Returns:
namespaces (list).
"""
return pm.listNamespaces()
def create_reference(self, sid_ref):
"""
create a reference to the scene defined by sid_ref on the current scene.
"""
import pymel.core as pm
cur_sid = self.get_sid()
task_name = sid_ref.get("task")
task_name = task_name.split("_")[-1]
if sid_ref.is_shot():
# create the namespace based on the sid
file_namespace = "{0}_{1}_{2}".format(sid_ref.get("seq"),
sid_ref.get("shot"),
task_name)
else:
# create the namespace based on the sid
file_namespace = "{0}_{1}".format(sid_ref.get("name"), task_name)
namespace_list = pm.listNamespaces(
) # get the namespace list of all references
counter = self.make_counter(
file_namespace, namespace_list) # return a formatted counter
file_namespace += "__" + counter
# create the reference
pm.createReference(sid_ref.path, namespace=file_namespace)
def test_noop_if_namespace_already_exists(self):
pm.namespace(set=':')
ns_foo = self.create_namespace('foo')
namespaceutils.add_namespace_to_root('foo')
expected = [ns_foo]
result = pm.listNamespaces(recursive=True)
self.assertListEqual(expected, result)
def test_not_root_with_leading_colon(self):
pm.namespace(set=':')
ns_bar = self.create_namespace('bar')
pm.namespace(set=':bar')
ns = namespaceutils.add_namespace_to_root(':foo')
expected = [':bar', ':foo']
result = [str(x) for x in pm.listNamespaces(recursive=True)]
self.assertListEqual(expected, result)
def delete_all_namespaces():
"""
Delete all the namespaces in the scene and merge them with the root.
"""
namespaces = pm.listNamespaces(recursive=True, internal=False)
for ns in reversed(namespaces):
pm.namespace(removeNamespace=ns, mergeNamespaceWithRoot=True)
print('{} name spaces removed'.format(len(namespaces)))
def fix(self):
"""@brief Delete the namespace in the scene.
"""
for namespace in pm.listNamespaces():
for elem in namespace.ls():
elem.rename(elem.split(":")[-1])
namespace.remove()
self.run()
def namespace_deleter(cls):
"""the legendary namespace deleter from Mehmet Erer
finds and deletes unused namespaces
"""
all_namespaces = pm.listNamespaces()
ref_namespaces = [ref.namespace for ref in pm.listReferences()]
missing_namespaces = []
from anima.ui.progress_dialog import ProgressDialogManager
if len(all_namespaces) > 0:
pdm = ProgressDialogManager()
pdm.close()
caller = pdm.register(len(all_namespaces),
'Locating Unused Namespaces...')
for nsa in all_namespaces:
i = 0
for nsr in ref_namespaces:
i += 1
if nsr == nsa:
break
if i == len(ref_namespaces):
missing_namespaces.append(nsa)
caller.step()
if len(missing_namespaces) > 0:
caller = pdm.register(len(missing_namespaces),
'Deleting Unused Namespaces...')
for ns in missing_namespaces:
ns_info = pm.namespaceInfo(ns, lon=1, fn=1, r=1)
if len(ns_info) > 0:
nsc = ns_info[len(ns_info) - 1]
nsc_array = nsc.split(':')
if len(nsc_array) > 0:
for del_nsc in nsc_array:
pm.namespace(rm=del_nsc, mnr=1)
else:
pm.namespace(rm=ns, mnr=1)
print('Deleted -> :' + ns)
caller.step()
else:
pm.warning(
'There are no first-level unused namespaces in this scene.'
)
if len(ref_namespaces) == 0 and len(all_namespaces) > 0:
for ns in all_namespaces:
pm.namespace(rm=ns, mnr=1)
print('Deleted -> : %s' % ns)
pm.warning(
'There are no references in this scene. All empty namespaces '
'are deleted.'
)
def exportAnimation(path=None):
"""
Bakes and exports animation on a rig in the scene.
Args:
path(str): An destination fbx path to export.
"""
if path is None:
path = pmc.sceneName()
path = path.replace('.ma', '.fbx')
# Get the root joint
root = None
namespace = None
for namespace in pmc.listNamespaces():
root = getRootJoint(namespace)
if root is not None:
namespace = namespace
break
if root is None:
raise RootJointException('Could not find a root in the scene with a namespace.')
try:
pmc.undoInfo(openChunk=True)
# Create a duplicate root joint
dupRoot = pmc.duplicate(root)[0]
pmc.rename(dupRoot, root.nodeName().split(':')[-1])
# Copy animation tags
copyTagAttribiutes(root, dupRoot)
# Bind skeleton
constraints = []
exportJoints = [dupRoot] + getBindSkeleton()
for joint in [dupRoot] + getBindSkeleton():
source = pmc.PyNode('%s:%s' % (namespace, joint.nodeName()))
constraints.append(pmc.parentConstraint(source, joint))
# Bake animation and remove constraints
bakeAnimation(exportJoints)
pmc.delete(constraints)
# Export animation and convert to hkx
exportFbx([dupRoot] + getBindSkeleton(), path=path, animation=True)
ckcmd.importanimation(
getSceneSkeletonHkx(legacy=True), path,
getSceneAnimationDirectory(), cache_txt=getSceneCacheFile(),
behavior_directory=getSceneBehaviorDirectory()
)
# TODO copy cache file to correct directory
finally:
pmc.undoInfo(closeChunk=True)
def get_namespace_as_pynode(namespace_string):
namespace = None
try:
namespace = pm.Namespace(namespace_string)
except ValueError:
for ns in pm.listNamespaces(recursive=True):
if ns.endswith(namespace_string):
namespace = ns
break
if namespace:
return namespace
raise ValueError("Namespace '{}' does not exist.".format(namespace_string))
def delete_empty_namespaces():
'''
Remove all empty namespaces from bottom up to remove children namespaces first
'''
namespace_list = []
for ns in pm.listNamespaces( recursive =True, internal =False):
namespace_list.append(ns)
# Reverse Iterate through the contents of the list to remove the deepest layers first
for ns in reversed(namespace_list):
if not pm.namespaceInfo(ns, ls=True):
pm.namespace(removeNamespace = ns, mergeNamespaceWithRoot = True)
def delete_empty_namespaces():
"""checks and deletes empty namespaces
"""
# only allow namespaces with DAG objects in it and no child namespaces
empty_namespaces = [
ns for ns in pm.listNamespaces(recursive=True)
if len(pm.ls(ns.listNodes(), dag=True, mat=True)) == 0
and len(ns.listNamespaces()) == 0
]
# remove all empty
for ns in empty_namespaces:
pm.namespace(rm=ns, mnr=1)
def delete_empty_namespaces():
"""checks and deletes empty namespaces
"""
# only allow namespaces with DAG objects in it and no child namespaces
empty_namespaces = [
ns for ns in pm.listNamespaces(recursive=True)
if len(pm.ls(ns.listNodes(), dag=True, mat=True)) == 0
and len(ns.listNamespaces()) == 0
]
# remove all empty
for ns in empty_namespaces:
pm.namespace(rm=ns, mnr=1)
def set_namespace(namespace, start_at_root=False):
if start_at_root:
pm.namespace(set=':')
try:
pm.namespace(set=namespace)
except RuntimeError as missing_namespace_error:
check_name = namespace
if not check_name.startswith(':'):
check_name = ':{}'.format(check_name)
current_ns = pm.namespaceInfo(currentNamespace=True)
nested_ns = pm.listNamespaces(root=current_ns,
recursive=True,
internal=False)
for ns in nested_ns:
if ns.endswith(check_name):
pm.namespace(set=ns)
return ns
all_ns = pm.listNamespaces(root=None, recursive=True, internal=False)
for ns in all_ns:
if ns.endswith(check_name):
pm.namespace(set=ns)
return ns
raise missing_namespace_error
def ar_removeNamespace(namespaceName):
"""
@ remove namespace of passed argument.
Args:
namespaceName (str): namespace without colon ex (MSH).
Returns:
bool.
"""
allNameSpaces = pm.listNamespaces()
for each in allNameSpaces:
if each == ':' + namespaceName:
pm.namespace(rm=each[1:], mnr=True)
ar_qui.ar_displayMessage('success', 'namespace successfully removed.')
return True
def check(self):
"""@brief Check if there is some namespace in the scene.
"""
BadNamespaces = list()
for namespace in pm.listNamespaces():
BadNamespaces.append(namespace)
if not BadNamespaces:
self.status = "OK"
else:
self.status = self.errorMode
self.errorNodes = namespace
for namespace in BadNamespaces:
self.addError("namespace %s exist" % namespace)
self.errorMessage = "%s namespace" % (len(BadNamespaces))
def removeNamespace(namespaceSelected):
""" !@Brief
Remove Namespace to selected garments, namespace will generate error otherwise
@param namespaceSelected: List, a list of namespace
"""
namespacesInScene = []
for ns in pm.listNamespaces(recursive=True, internal=False):
namespacesInScene.append(ns)
namespaces = []
for namespace in namespaceSelected:
if namespace in namespacesInScene:
namespaces.append(namespace)
for ns in reversed(namespaces):
currentSpace = ns
pm.namespace(removeNamespace=ns, mergeNamespaceWithRoot=True)
def _removeNamespace(self):
allNameSpaces = pm.listNamespaces()
for each in allNameSpaces:
if each == ':' + self.namespaceName:
pm.namespace(rm=each[1:], mnr=True)
def check_no_namespace():
"""there should be no namespaces in a model file
"""
if len(pm.listNamespaces()):
raise PublishError(
'There should be no <b>Namespaces</b> in a <b>Model</b> scene.')
def test_root_current_namespace(self):
pm.namespace(set=':')
ns = namespaceutils.add_namespace_to_root('foo')
expected = [ns]
result = pm.listNamespaces(recursive=True)
self.assertListEqual(expected, result)