def returnTagInfoShortName(info,tagType):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns tag info from the object if it exists. If not, it looks upstream
before calling it quits. Also, it checks the types and names dictionaries for
short versions
ARGUMENTS:
obj(string) - the object we're starting from
tag(string)
RETURNS:
Success - name(string)
Failure - False
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
if tagType == 'cgmType':
if info in typesDictionary:
return typesDictionary.get(info)
else:
return info
else:
if info in namesDictionary:
return namesDictionary.get(info)
else:
return info
def returnTagInfoShortName(info,tagType):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns tag info from the object if it exists. If not, it looks upstream
before calling it quits. Also, it checks the types and names dictionaries for
short versions
ARGUMENTS:
obj(string) - the object we're starting from
tag(string)
RETURNS:
Success - name(string)
Failure - False
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
if tagType == 'cgmType':
if info in typesDictionary:
return typesDictionary.get(info)
else:
return info
else:
if info in namesDictionary:
return namesDictionary.get(info)
else:
return info
def doUpdateName(obj):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Names an object's heirarchy below
ARGUMENTS:
obj(string) - the object we'd like to startfrom
RETURNS:
Nothin
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
### input check
assert mc.objExists(obj) is True, "'%s' doesn't exist" %obj
typeDictionary = dictionary.initializeDictionary(typesDictionaryFile)
attrName = ('%s%s' % (obj,'.cgmName'))
# Look for cgmName tag
if search.returnNameTag(obj) is not False:
if mc.getAttr(attrName,lock=True) == True:
mc.setAttr(attrName,lock=False)
mc.setAttr(attrName,obj, type='string')
mc.setAttr(attrName,lock=True)
else:
attributes.storeInfo(obj,'cgmName',obj,True)
return doNameObject(obj)
def returncgmTemplatePartPositionData(part):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the order for names in a list format
ARGUMENTS:
Nothin
RETURNS:
settings(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
returnList = []
listBuffer = dict.get('%s%s'%(part,'_PositionalData'))
if listBuffer != None:
listSplit = listBuffer.split('|')
for pos in listSplit:
posBufferRaw = pos.split(',')
posBuffer = []
for n in posBufferRaw:
posBuffer.append(float(n))
returnList.append(posBuffer)
return returnList
else:
return False
def doUpdateName(obj, *a, **kw):
"""
Updates the name of an object
ARGUMENTS:
obj(string) - the object we'd like to startfrom
RETURNS:
Nothin
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
### input check
assert mc.objExists(obj) is True, "'%s' doesn't exist" % obj
typeDictionary = dictionary.initializeDictionary(typesDictionaryFile)
attrName = ('%s%s' % (obj, '.cgmName'))
# Look for cgmName tag
if search.returnNameTag(obj) is not False:
if mc.getAttr(attrName, lock=True) == True:
mc.setAttr(attrName, lock=False)
mc.setAttr(attrName, obj, type='string')
mc.setAttr(attrName, lock=True)
else:
attributes.storeInfo(obj, 'cgmName', obj, True)
return doNameObject(obj, *a, **kw)
def returncgmTemplatePartPositionData(part):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the order for names in a list format
ARGUMENTS:
Nothin
RETURNS:
settings(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
returnList = []
listBuffer = dict.get('%s%s' % (part, '_PositionalData'))
if listBuffer != None:
listSplit = listBuffer.split('|')
for pos in listSplit:
posBufferRaw = pos.split(',')
posBuffer = []
for n in posBufferRaw:
posBuffer.append(float(n))
returnList.append(posBuffer)
return returnList
else:
return False
def returnCGMSetting(setting):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the divider string
ARGUMENTS:
Nothin
RETURNS:
divider(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
return (dict.get(setting))
def returnCGMSetting(setting):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the divider string
ARGUMENTS:
Nothin
RETURNS:
divider(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
return (dict.get(setting))
def returnCGMOrder():
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the order for names in a list format
ARGUMENTS:
Nothin
RETURNS:
order(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
orderBuffer = dict.get('nameOrder')
return (orderBuffer.split(','))
def returnCGMOrder():
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the order for names in a list format
ARGUMENTS:
Nothin
RETURNS:
order(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
orderBuffer = dict.get('nameOrder')
return (orderBuffer.split(','))
def returncgmTemplateCoreNames(part):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the part names for a part
ARGUMENTS:
Nothin
RETURNS:
settings(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
settingsBuffer = dict.get('%s%s' % (part, '_NameList'))
if settingsBuffer > 0:
return (settingsBuffer.split(','))
else:
return False
def returncgmTemplateCoreNames(part):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the part names for a part
ARGUMENTS:
Nothin
RETURNS:
settings(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
settingsBuffer = dict.get('%s%s'%(part,'_NameList'))
if settingsBuffer > 0:
return (settingsBuffer.split(','))
else:
return False
def returncgmTemplateSizeRatios(part):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the part names for a part
ARGUMENTS:
Nothin
RETURNS:
settings(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
settingsBuffer = dict.get('%s%s'%(part,'_sizeRatios'))
if settingsBuffer > 0:
splitBufferRaw = (settingsBuffer.split(','))
returnBuffer = []
for n in splitBufferRaw:
returnBuffer.append(float(n))
return returnBuffer
else:
return False
def returncgmTemplateSizeRatios(part):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the part names for a part
ARGUMENTS:
Nothin
RETURNS:
settings(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
settingsBuffer = dict.get('%s%s' % (part, '_sizeRatios'))
if settingsBuffer > 0:
splitBufferRaw = (settingsBuffer.split(','))
returnBuffer = []
for n in splitBufferRaw:
returnBuffer.append(float(n))
return returnBuffer
else:
return False
def returnSettingsData(setting,parsed=True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the divider string
ARGUMENTS:
setting(string) - the dictionary key to get the data from
RETURNS:
divider(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
dataBuffer = (dict.get(setting))
if parsed == False:
return dataBuffer
else:
if '|' in list(dataBuffer):
return dataBuffer.split('|')
elif ',' in list(dataBuffer):
return dataBuffer.split(',')
else:
return dataBuffer
def returnSettingsData(setting, parsed=True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns the divider string
ARGUMENTS:
setting(string) - the dictionary key to get the data from
RETURNS:
divider(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
dict = dictionary.initializeDictionary(settingsDictionaryFile)
dataBuffer = (dict.get(setting))
if parsed == False:
return dataBuffer
else:
if '|' in list(dataBuffer):
return dataBuffer.split('|')
elif ',' in list(dataBuffer):
return dataBuffer.split(',')
else:
return dataBuffer
def returnObjectGeneratedNameDict(obj,ignore='none'):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(settingsDictionaryFile)
namesDict={}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs,order)
#>>> Tag ignoring
if ignore != 'none':
if ignore in order:
order.remove(ignore)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj,tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
""" remove tags up stream that we don't want if they don't exist on the actual object"""
if mc.objExists(obj+'.cgmTypeModifier') != True:
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj,'cgmName')
typeTag = search.returnTagInfo(obj,'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if childrenObjects > 0 and isType == 'transform' and typeTag == False:
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmDirection') != None:
groupNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmDirectionModifier') != None:
groupNamesDict['cgmDirectionModifier'] = namesDict.get('cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
"""if there is, does it exist """
if mc.objExists(nameObj) == True:
"""basic child object with cgmName tag """
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmDirection') != None:
childNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmNameModifier') != None:
childNamesDict['cgmNameModifier'] = namesDict.get('cgmNameModifier')
if namesDict.get('cgmDirectionModifier') != None:
childNamesDict['cgmDirectionModifier'] = namesDict.get('cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj,False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
"""if so, it's a special case"""
moduleObj = search.returnMatchedTagObjectUp(obj,'cgmType','module')
masterObj = search.returnMatchedTagObjectUp(obj,'cgmType','master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
return namesDict
else:
return namesDict
reload(distance)
reload(names)
reload(attributes)
reload(names)
reload(rigging)
reload(constraints)
reload(curves)
reload(dictionary)
reload(settings)
reload(lists)
reload(modules)
reload(cgmMath)
reload(controlBuilder)
reload(logic)
typesDictionary = dictionary.initializeDictionary(
settings.getTypesDictionaryFile())
namesDictionary = dictionary.initializeDictionary(
settings.getNamesDictionaryFile())
settingsDictionary = dictionary.initializeDictionary(
settings.getSettingsDictionaryFile())
axisDirectionsByString = ['x+', 'y+', 'z+', 'x-', 'y-', 'z-']
geoTypes = 'nurbsSurface', 'mesh', 'poly', 'subdiv'
CharacterTypes = 'Bio', 'Mech', 'Prop'
moduleTypeToFunctionDict = {
'None': ModuleFactory,
'segment': Limb.module.Segment
}
moduleTypeToMasterClassDict = {
from cgm.lib import dictionary
from cgm.lib import settings
from cgm.lib import distance
from cgm.lib import search
from cgm.lib import lists
from cgm.lib import rigging
from cgm.lib import guiFactory
import copy
import random
reload(dictionary)
reload(lists)
reload(attributes)
typesDictionary = dictionary.initializeDictionary(settings.getTypesDictionaryFile())
settingsDictionary = dictionary.initializeDictionary( settings.getSettingsDictionaryFile())
settingsDictionaryFile = settings.getSettingsDictionaryFile()
def cgmTagToFloatAttr(obj,cgmTag,*a, **kw):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Lays out a seies of objects in column and row format
ARGUMENTS:
objectList(string)
columnNumber(int) - number of columns
RETURNS:
Nada
def returnObjectGeneratedNameDict(obj, ignore=[False]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(
settingsDictionaryFile)
namesDict = {}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs, order)
#>>> Tag ignoring
if ignore:
for i in ignore:
if i in order:
order.remove(i)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj, tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
""" remove tags up stream that we don't want if they don't exist on the actual object"""
if mc.objExists(obj + '.cgmTypeModifier') != True:
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj, 'cgmName')
typeTag = search.returnTagInfo(obj, 'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if childrenObjects > 0 and isType == 'transform' and typeTag == False:
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmDirection') != None:
groupNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmDirectionModifier') != None:
groupNamesDict['cgmDirectionModifier'] = namesDict.get(
'cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
"""if there is, does it exist """
if mc.objExists(nameObj) == True:
"""basic child object with cgmName tag """
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmDirection') != None:
childNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmNameModifier') != None:
childNamesDict['cgmNameModifier'] = namesDict.get(
'cgmNameModifier')
if namesDict.get('cgmDirectionModifier') != None:
childNamesDict['cgmDirectionModifier'] = namesDict.get(
'cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj, False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
"""if so, it's a special case"""
moduleObj = search.returnMatchedTagObjectUp(
obj, 'cgmType', 'module')
masterObj = search.returnMatchedTagObjectUp(
obj, 'cgmType', 'master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,
ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName + '_' + nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,
ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName + '_' + nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
return namesDict
else:
return namesDict
def returnObjectGeneratedNameDict(obj,ignore=[False]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
_str_funcName = "returnObjectGeneratedNameDict"
log.debug(">>> %s >>> "%(_str_funcName) + "="*75)
#_str_funcName = "returnObjectGeneratedNameDict(%s,ignore = %s)"%(obj,ignore)
if type(ignore) is not list:ignore = [ignore]
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(settingsDictionaryFile)
namesDict={}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs,order)
#>>> Tag ignoring
if ignore:
for i in ignore:
if i in order:
order.remove(i)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj,tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
_iterator = search.findRawTagInfo(obj,'cgmIterator')
if _iterator is not False:
log.debug("Iterator found")
namesDict['cgmIterator'] = (_iterator)
# remove tags up stream that we don't want if they don't exist on the actual object"""
if not mc.objExists(obj+'.cgmTypeModifier'):
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
log.debug("%s >>> initial nameDict: %s "%(_str_funcName,namesDict))
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj,'cgmName')
typeTag = search.returnTagInfo(obj,'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if isType == 'group' and typeTag == False:
log.debug("%s >>> group and no typeTag..."%(_str_funcName))
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
#If we have a name object or shape
log.debug("%s >>> nameObj not None or isType is 'shape'..."%(_str_funcName))
if mc.objExists(nameObj) and mc.attributeQuery ('cgmName',node=obj,msg=True):
log.debug("%s >>> nameObj exists: '%s'..."%(_str_funcName,nameObj))
#Basic child object with cgmName tag
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
if namesDict.get('cgmIterator') != None:
childNamesDict['cgmIterator'] = namesDict.get('cgmIterator')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
log.debug("%s >>> child name object..."%(_str_funcName))
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj,False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
log.debug("%s >>> special case..."%(_str_funcName))
moduleObj = search.returnMatchedTagObjectUp(obj,'cgmType','module')
masterObj = search.returnMatchedTagObjectUp(obj,'cgmType','master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
log.debug("%s >>> No special case found. %s"%(_str_funcName,namesDict))
return namesDict
else:
return namesDict
