def gatherInfluenceData(self, dagPath, components):
"""
Get the influence data
"""
weights = self.__getCurrentWeights(dagPath, components)
influencePaths = OM.MDagPathArray()
numInfluences = self.fn.influenceObjects(influencePaths)
numComponentsPerInfluence = weights.length() / numInfluences
self.progressBar_start(stepMaxValue=influencePaths.length(),
statusMessage='Calculating....',
interruptableState=False)
_d_influenceData = {}
for i in range(influencePaths.length()):
_k = str(i)
influenceName = influencePaths[i].partialPathName()
influenceWithoutNamespace = names.getBaseName(influenceName)
_d_influenceData[_k] = {'name': influenceWithoutNamespace,
'position':distance.returnWorldSpacePosition(influenceName)}
# store weights by influence & not by namespace so it can be imported with different namespaces.
self.progressBar_iter(status = 'Getting {0}...data'.format(influenceName))
self._d_data['weights'][_k] = \
[weights[jj*numInfluences+i] for jj in range(numComponentsPerInfluence)]
self._d_data['influences']['data'] = _d_influenceData
self.progressBar_end()
def gatherInfluenceData(self, dagPath, components):
"""
Get the influence data
"""
weights = self.__getCurrentWeights(dagPath, components)
influencePaths = OM.MDagPathArray()
numInfluences = self.fn.influenceObjects(influencePaths)
numComponentsPerInfluence = weights.length() / numInfluences
self.progressBar_start(stepMaxValue=influencePaths.length(),
statusMessage='Calculating....',
interruptableState=False)
_d_influenceData = {}
for i in range(influencePaths.length()):
_k = str(i)
influenceName = influencePaths[i].partialPathName()
influenceWithoutNamespace = names.getBaseName(influenceName)
_d_influenceData[_k] = {'name': influenceWithoutNamespace,
'position':distance.returnWorldSpacePosition(influenceName)}
# store weights by influence & not by namespace so it can be imported with different namespaces.
self.progressBar_iter(status = 'Getting {0}...data'.format(influenceName))
self._d_data['weights'][_k] = \
[weights[jj*numInfluences+i] for jj in range(numComponentsPerInfluence)]
self._d_data['influences']['data'] = _d_influenceData
self.progressBar_end()
def sortChildrenByName(obj):
_l = search.returnChildrenObjects(obj,fullPath = True)
if not _l:
log.error("sortChildrenByName>> No children found.")
return False
_d = {}
for i,o in enumerate(_l):
_bfr = names.getBaseName(o)
if _bfr not in _d.keys():
_d[_bfr] = o
else:
_d[names.getShortName(o)] = o
l_keys = _d.keys()
l_keys.sort()
for k in l_keys:
o = _d[k]
o = doParentToWorld(o)
mc.parent(o,obj)
return True
def sortChildrenByName(obj):
_l = search.returnChildrenObjects(obj, fullPath=True)
if not _l:
log.error("sortChildrenByName>> No children found.")
return False
_d = {}
for i, o in enumerate(_l):
_bfr = names.getBaseName(o)
if _bfr not in _d.keys():
_d[_bfr] = o
else:
_d[names.getShortName(o)] = o
l_keys = _d.keys()
l_keys.sort()
for k in l_keys:
o = _d[k]
o = doParentToWorld(o)
mc.parent(o, obj)
return True
def _fnc_skinCluster(self):
self.log_toDo("Add ability to check exisiting targets skin")
self.log_toDo("Add more than just skincluster ability?...")
#..........................................................
_targetMesh = self.mData.d_target['mesh']
#...See if we have a skin cluster...
_targetSkin = skinning.querySkinCluster(_targetMesh) or False
if _targetSkin:
if self._l_missingInfluences:
self.log_info("Adding influences...")
for infl in self._l_missingInfluences:
mc.skinCluster(_targetSkin, edit = True, ai = infl)
#try:mc.delete(_targetSkin)
#except:pass
else:
#...create our skin cluster
_l_bind = copy.copy(self.l_jointsToUse)
_l_bind.append(_targetMesh)
_targetSkin = mc.skinCluster(_l_bind,tsb=True,n=(names.getBaseName(_targetMesh)+'_skinCluster'))[0]
self.mData.d_target['skin'] = _targetSkin#...update the stored data
self.log_info("Created '{0}'".format(_targetSkin) + cgmGeneral._str_subLine)
def get_objNameDict(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)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
try:
_str_funcName = "get_objNameDict"
log.debug(">>> %s >>> " % (_str_funcName) + "=" * 75)
if type(ignore) is not list: ignore = [ignore]
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.get_tagInfo(obj, tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
if 'cgmIterator' in order:
_iterator = ATTR.get(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 = False
cgmNameAttrType = ATTR.get_type(obj, 'cgmName')
log.debug("cgmNameAttrType: {0}".format(cgmNameAttrType))
if cgmNameAttrType == 'message':
#nameObj = SEARCH.get_nodeTagInfo(obj,'cgmName')
nameObj = ATTR.get_message(
obj, 'cgmName',
simple=True) #SEARCH.get_nodeTagInfo(obj,'cgmName')
if nameObj:
nameObj = nameObj[0]
nameObjDict = get_objNameDict(nameObj)
#pprint.pprint(nameObjDict)
for k in 'cgmDirection', 'cgmPosition':
#if nameObjDict.get(k) and namesDict.get(k):
try:
namesDict.pop(k)
except:
pass
log.debug("nameObj: {0}".format(nameObj))
namesDict['cgmName'] = names.getBaseName(nameObj)
return namesDict
typeTag = SEARCH.get_nodeTagInfo(obj, 'cgmType')
isType = SEARCH.VALID.get_mayaType(obj)
isShape = SEARCH.VALID.is_shape(obj)
"""first see if it's a group """
if isType == 'group' and typeTag == False:
childrenObjects = TRANS.children_get(obj, 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'] = CORESHARE.d_cgmTypes.get('transform')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif isType in ['joint']:
return namesDict
elif isShape:
#If we have a name object or shape
log.debug("%s >>> nameObj not None or isType is 'shape'..." %
(_str_funcName))
if isShape:
#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 isShape or 'Constraint' in isType:
"""if so, it's a child name object"""
log.debug("%s >>> child name object..." % (_str_funcName))
childNamesDict = {}
childNamesDict['cgmName'] = TRANS.parent_get(obj, False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
log.debug("%s >>> No special case found. %s" %
(_str_funcName, namesDict))
return namesDict
else:
return namesDict
except Exception, err:
raise cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def _fnc_processData(self):
'''
Sort out the components
'''
#...check if our vtx counts match...
self.log_toDo("Remap dictionary argument")
self.log_toDo("Non matching mesh types")
self.mData.d_target = data.validateMeshArg(self.mData.d_target['mesh'])#...update
_int_sourceCnt = int(self.mData.d_source['pointCount'])
_int_targetCnt = int(self.mData.d_target['pointCount'])
_type_source = self.mData.d_source['meshType']
_type_target = self.mData.d_target['meshType']
_target = self.mData.d_target['mesh']
_component = self.mData.d_target['component']
self.log_infoDict(self.mData.d_target,'target dict...')
#if int(_int_sourceCnt) != int(_int_targetCnt):
#return self._FailBreak_("Haven't implemented non matching component counts | source: {0} | target: {1}".format(_int_sourceCnt,_int_targetCnt))
if not _type_source == _type_target:
return self._FailBreak_("Haven't implemented non matching mesh types | source: {0} | target: {1}".format(_type_source,_type_target))
#...generate a processed list...
#[[jntIdx,v],[jntIdx,v]....] -- the count in the list is the vert count
_raw_componentWeights = self.mData.d_sourceInfluences['componentWeights']
_raw_blendweights = self.mData.d_sourceInfluences['blendWeights']
_l_cleanData = []
#...First loop is to only initially clean the data...
for i in range(_int_sourceCnt):#...for each vert
_str_i = str(i)
_subL = []
_bfr_raw = _raw_componentWeights[_str_i]
_bfr_toNormalize = []
_bfr_clean = {}
_d_normalized = {}
for k,value in _bfr_raw.iteritems():
_bfr_clean[int(k)] = float(value)
_d_normalized[int(k)] = None
#normalize the values...
for k,value in _bfr_clean.iteritems():
_bfr_toNormalize.append(value)
_bfr_normalized = cgmMath.normSumList(_bfr_toNormalize,1.0)
#self.log_info("To Normalize: {0}".format(_bfr_toNormalize))
#self.log_info("Normalized: {0}".format(_bfr_normalized))
#self.log_info("{0} pre sum: {1}".format(i,sum(_bfr_toNormalize)))
#self.log_info("{0} sum: {1}".format(i,sum(_bfr_normalized)))
for ii,k in enumerate(_d_normalized.keys()):
_d_normalized[k] = _bfr_normalized[ii]
#self.log_info("clean: {0}".format(_bfr_clean))
#self.log_info("norm: {0}".format(_d_normalized))
if not cgmMath.isFloatEquivalent(1.0, sum(_bfr_normalized) ):
self.log_info("vert {0} not normalized".format(i))
#self.log_info("vert {0} base: {1}".format(i,_bfr_toNormalize))
#self.log_info("vert {0} norm: {1}".format(i,_bfr_normalized))
_l_cleanData.append(_d_normalized)
#if i == 3:return self._FailBreak_("stop")
self._l_processed = _l_cleanData#...initial push data
#...nameMatch ------------------------------------------------------------------------
if self._b_nameMatch:
self.log_info("nameMatch attempt...")
_l_configInfluenceList = self.l_configInfluenceList
_l_jointsToUseBaseNames = [names.getBaseName(n) for n in self.l_jointsToUse]
for n in _l_jointsToUseBaseNames:#...see if all our names are there
if not n in _l_configInfluenceList:
#return self._FailBreak_
self.log_warning("nameMatch... joint '{0}' from joints to use list not in config list".format(n))
#self._FailBreak_("nameMatch... joint '{0}' from joints to use list not in config list".format(n))
#return False
#return False
_d_rewire = {}
for i,n in enumerate(_l_configInfluenceList):
_idx_base = _l_jointsToUseBaseNames.index(n)
#self.log_error("Rewire. Name:{0} | config idx:{1} ===> currentIdx: {2}".format(n,_idx_config,i))
_d_rewire[i] = _idx_base
"""
for i,n in enumerate(_l_configInfluenceList):
if _l_jointsToUseBaseNames[i] != n:
self.log_error("Name mismatch. idx:{0} | config:{1} | useJoint:{2}".format(i,n,_l_jointsToUseBaseNames[i]))
#_d_rewire[i] = _l_configInfluenceList.index(_l_jointsToUseBaseNames[i])
_d_rewire[i] = _l_configInfluenceList.index(_l_jointsToUseBaseNames[_l_jointsToUseBaseNames.index(n)])
"""
self.log_infoDict(_d_rewire,"Rewire...")
for i,d in enumerate(self._l_processed):
_d_dup = copy.copy(d)
#self.log_info("{0} before remap: {1}".format(i,d))
for r1,r2 in _d_rewire.iteritems():#...{1:2, 2:1}
if r1 in _d_dup.keys():#...1,2
if r2 in _d_dup.keys():
_bfr1 = _d_dup[r1]
_bfr2 = _d_dup[r2]
d[r1] = _bfr2
d[r2] = _bfr1
else:
d[r2] = d.pop(r1)
#self.log_info("{0} after remap: {1}".format(i,d))
if int(_int_sourceCnt) != int(_int_targetCnt) or self._b_forceClosestComponent:
try:#closest to remap ------------------------------------------------------------------------
self.log_warning("Non matching component counts. Using closestTo method to remap")
_l_closestRetarget = []
#...generate a posList of the source data
l_source_pos = []
_d_pos = self.mData.d_source['d_vertPositions']
for i in range(_int_sourceCnt):
l_source_pos.append([float(v) for v in _d_pos[str(i)]])#...turn our strings to values
self.progressBar_start(stepMaxValue=_int_targetCnt,
statusMessage='Calculating....',
interruptableState=False)
for i in range(_int_targetCnt):
_str_vert = "{0}.{1}[{2}]".format(_target,_component,i)
self.progressBar_iter(status = "Finding closest to '{0}'".format(_str_vert))
#self.log_info(_str_vert)
_pos = distance.returnWorldSpacePosition(_str_vert)#...get position
_closestPos = distance.returnClosestPoint(_pos, l_source_pos)#....get closest
_closestIdx = l_source_pos.index(_closestPos)
#self.log_info("target idx: {0} | Closest idx: {1} | value{2}".format(i,_closestIdx,_l_cleanData[_closestIdx]))
_l_closestRetarget.append(_l_cleanData[_closestIdx])
self.progressBar_end()
self._l_processed = _l_closestRetarget#...push it backs
self._b_smooth = True
if _int_targetCnt >= _int_sourceCnt:
self._f_smoothWeightsValue = .00005
else:
self._f_smoothWeightsValue = .5
self.log_info("closestTo remap complete...")
except Exception,error:
raise Exception,"closestTo remap failure | {0}".format(error)
def _fnc_processData(self):
'''
Sort out the components
'''
#...check if our vtx counts match...
self.log_toDo("Remap dictionary argument")
self.log_toDo("Non matching mesh types")
self.mData.d_target = data.validateMeshArg(self.mData.d_target['mesh'])#...update
_int_sourceCnt = int(self.mData.d_source['pointCount'])
_int_targetCnt = int(self.mData.d_target['pointCount'])
_type_source = self.mData.d_source['meshType']
_type_target = self.mData.d_target['meshType']
_target = self.mData.d_target['mesh']
_component = self.mData.d_target['component']
self.log_infoDict(self.mData.d_target,'target dict...')
#if int(_int_sourceCnt) != int(_int_targetCnt):
#return self._FailBreak_("Haven't implemented non matching component counts | source: {0} | target: {1}".format(_int_sourceCnt,_int_targetCnt))
if not _type_source == _type_target:
return self._FailBreak_("Haven't implemented non matching mesh types | source: {0} | target: {1}".format(_type_source,_type_target))
#...generate a processed list...
#[[jntIdx,v],[jntIdx,v]....] -- the count in the list is the vert count
_raw_componentWeights = self.mData.d_sourceInfluences['componentWeights']
_raw_blendweights = self.mData.d_sourceInfluences['blendWeights']
_l_cleanData = []
#...First loop is to only initially clean the data...
for i in range(_int_sourceCnt):#...for each vert
_str_i = str(i)
_subL = []
_bfr_raw = _raw_componentWeights[_str_i]
_bfr_toNormalize = []
_bfr_clean = {}
_d_normalized = {}
for k,value in _bfr_raw.iteritems():
_bfr_clean[int(k)] = float(value)
_d_normalized[int(k)] = None
#normalize the values...
for k,value in _bfr_clean.iteritems():
_bfr_toNormalize.append(value)
_bfr_normalized = cgmMath.normSumList(_bfr_toNormalize,1.0)
#self.log_info("To Normalize: {0}".format(_bfr_toNormalize))
#self.log_info("Normalized: {0}".format(_bfr_normalized))
#self.log_info("{0} pre sum: {1}".format(i,sum(_bfr_toNormalize)))
#self.log_info("{0} sum: {1}".format(i,sum(_bfr_normalized)))
for ii,k in enumerate(_d_normalized.keys()):
_d_normalized[k] = _bfr_normalized[ii]
#self.log_info("clean: {0}".format(_bfr_clean))
#self.log_info("norm: {0}".format(_d_normalized))
if not cgmMath.isFloatEquivalent(1.0, sum(_bfr_normalized) ):
self.log_info("vert {0} not normalized".format(i))
#self.log_info("vert {0} base: {1}".format(i,_bfr_toNormalize))
#self.log_info("vert {0} norm: {1}".format(i,_bfr_normalized))
_l_cleanData.append(_d_normalized)
#if i == 3:return self._FailBreak_("stop")
self._l_processed = _l_cleanData#...initial push data
#...nameMatch ------------------------------------------------------------------------
if self._b_nameMatch:
self.log_info("nameMatch attempt...")
_l_configInfluenceList = self.l_configInfluenceList
_l_jointsToUseBaseNames = [names.getBaseName(n) for n in self.l_jointsToUse]
for n in _l_jointsToUseBaseNames:#...see if all our names are there
if not n in _l_configInfluenceList:
#return self._FailBreak_
self.log_warning("nameMatch... joint '{0}' from joints to use list not in config list".format(n))
#self._FailBreak_("nameMatch... joint '{0}' from joints to use list not in config list".format(n))
#return False
#return False
_d_rewire = {}
for i,n in enumerate(_l_configInfluenceList):
_idx_base = _l_jointsToUseBaseNames.index(n)
#self.log_error("Rewire. Name:{0} | config idx:{1} ===> currentIdx: {2}".format(n,_idx_config,i))
_d_rewire[i] = _idx_base
"""
for i,n in enumerate(_l_configInfluenceList):
if _l_jointsToUseBaseNames[i] != n:
self.log_error("Name mismatch. idx:{0} | config:{1} | useJoint:{2}".format(i,n,_l_jointsToUseBaseNames[i]))
#_d_rewire[i] = _l_configInfluenceList.index(_l_jointsToUseBaseNames[i])
_d_rewire[i] = _l_configInfluenceList.index(_l_jointsToUseBaseNames[_l_jointsToUseBaseNames.index(n)])
"""
self.log_infoDict(_d_rewire,"Rewire...")
for i,d in enumerate(self._l_processed):
_d_dup = copy.copy(d)
#self.log_info("{0} before remap: {1}".format(i,d))
for r1,r2 in _d_rewire.iteritems():#...{1:2, 2:1}
if r1 in _d_dup.keys():#...1,2
if r2 in _d_dup.keys():
_bfr1 = _d_dup[r1]
_bfr2 = _d_dup[r2]
d[r1] = _bfr2
d[r2] = _bfr1
else:
d[r2] = d.pop(r1)
#self.log_info("{0} after remap: {1}".format(i,d))
if int(_int_sourceCnt) != int(_int_targetCnt) or self._b_forceClosestComponent:
try:#closest to remap ------------------------------------------------------------------------
self.log_warning("Non matching component counts. Using closestTo method to remap")
_l_closestRetarget = []
#...generate a posList of the source data
l_source_pos = []
_d_pos = self.mData.d_source['d_vertPositions']
for i in range(_int_sourceCnt):
l_source_pos.append([float(v) for v in _d_pos[str(i)]])#...turn our strings to values
self.progressBar_start(stepMaxValue=_int_targetCnt,
statusMessage='Calculating....',
interruptableState=False)
for i in range(_int_targetCnt):
_str_vert = "{0}.{1}[{2}]".format(_target,_component,i)
self.progressBar_iter(status = "Finding closest to '{0}'".format(_str_vert))
#self.log_info(_str_vert)
_pos = distance.returnWorldSpacePosition(_str_vert)#...get position
_closestPos = distance.returnClosestPoint(_pos, l_source_pos)#....get closest
_closestIdx = l_source_pos.index(_closestPos)
#self.log_info("target idx: {0} | Closest idx: {1} | value{2}".format(i,_closestIdx,_l_cleanData[_closestIdx]))
_l_closestRetarget.append(_l_cleanData[_closestIdx])
self.progressBar_end()
self._l_processed = _l_closestRetarget#...push it backs
self._b_smooth = True
if _int_targetCnt >= _int_sourceCnt:
self._f_smoothWeightsValue = .00005
else:
self._f_smoothWeightsValue = .5
self.log_info("closestTo remap complete...")
except Exception,error:
raise Exception,"closestTo remap failure | {0}".format(error)
#...See if we have a skin cluster...
_targetSkin = skinning.querySkinCluster(_targetMesh) or False
if _targetSkin:
if self._l_missingInfluences:
self.log_info("Adding influences...")
for infl in self._l_missingInfluences:
try:mc.skinCluster(_targetSkin, edit = True, ai = infl)
except Exception,err:
log.error(err)
#try:mc.delete(_targetSkin)
#except:pass
else:
#...create our skin cluster
_l_bind = copy.copy(self.l_jointsToUse)
_l_bind.append(_targetMesh)
_targetSkin = mc.skinCluster(_l_bind,tsb=True,n=(names.getBaseName(_targetMesh)+'_skinCluster'))[0]
self.mData.d_target['skin'] = _targetSkin#...update the stored data
self.log_info("Created '{0}'".format(_targetSkin) + cgmGeneral._str_subLine)
#...Does this skin cluster have our expected targets?
def _fnc_applyData(self):
'''
'''
_targetSkin = self.mData.d_target['skin']
mi_skinCluster = cgmMeta.cgmNode(_targetSkin)
skinFn = OMA.MFnSkinCluster( mi_skinCluster.mNodeMObject )
#...get some api stuff
self.log_info("Adding influences...")
for infl in self._l_missingInfluences:
try:
mc.skinCluster(_targetSkin, edit=True, ai=infl)
except Exception, err:
log.error(err)
#try:mc.delete(_targetSkin)
#except:pass
else:
#...create our skin cluster
_l_bind = copy.copy(self.l_jointsToUse)
_l_bind.append(_targetMesh)
_targetSkin = mc.skinCluster(
_l_bind,
tsb=True,
n=(names.getBaseName(_targetMesh) + '_skinCluster'))[0]
self.mData.d_target[
'skin'] = _targetSkin #...update the stored data
self.log_info("Created '{0}'".format(_targetSkin) +
cgmGeneral._str_subLine)
#...Does this skin cluster have our expected targets?
def _fnc_applyData(self):
'''
'''
_targetSkin = self.mData.d_target['skin']
mi_skinCluster = cgmMeta.cgmNode(_targetSkin)
skinFn = OMA.MFnSkinCluster(mi_skinCluster.mNodeMObject)
