def getUParamOnCurve(obj = None, crv = None): """ Props to Marco Giordano for this method. Oddly, the distance method is faster.... @Parameters curve -- must be a curve instance or obj string points -- number of points you want on the curve returns param """ _str_funcName = 'getUParamOnCurve' log.info(">>> %s >> "%_str_funcName + "="*75) mi_obj = cgmValid.objString(obj) mi_crv = cgmValid.objString(crv,mayaType='nurbsCurve') mi_shape = cgmMeta.validateObjArg(mc.listRelatives(mi_crv,shapes = True)[0],mayaType='shape') pos = mc.xform(mi_obj,q=True, t=True, ws=True) point = OpenMaya.MPoint(pos[0],pos[1],pos[2]) #object.__getattribute__(self, "_MObject") curveFN = OpenMaya.MFnNurbsCurve(mi_shape.__getattribute__("_MObject")) paramUtil = OpenMaya.MScriptUtil() paramPtr = paramUtil.asDoublePtr() isOnCurve = curveFN.isPointOnCurve(point) if isOnCurve: curveFN.getParamAtPoint(point,paramPtr,0.001,OpenMaya.MSpace.kObject) else: point = curveFN.closestPoint(point,paramPtr,0.001,OpenMaya.MSpace.kObject) curveFN.getParamAtPoint(point,paramPtr,0.001,OpenMaya.MSpace.kObject) buffer = paramPtr del(paramPtr) return paramUtil.getDouble(buffer)
def aim(obj = None, target = None, aimAxis = "z+", upAxis = "y+",mode = 'local',vectorUp = None): """ Aim functionality. :parameters: obj(str): Object to modify target(str): object to copy from aimAxis(str): axis that is pointing forward upAxis(str): axis that is pointing up vectorUp(vector): Only relevent during vector mode mode(str): 'local'-- use standard maya aiming with local axis 'world' -- use standard maya aiming with world axis 'matrix' -- use Bokser's fancy method 'vector' -- maya standard with vector up axis :returns success(bool) """ _str_func = 'aim' _obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj") _target = VALID.objString(target, noneValid=False, calledFrom = __name__ + _str_func + ">> validate target") targetPos = POS.get(_target) log.debug("|{0}| >> obj: {1} | target:{2} | mode: {3}".format(_str_func,_obj,_target,mode)) aim_atPoint(_obj, targetPos, aimAxis, upAxis, mode,vectorUp) return True
def bakeTempLocator(self, startTime=None, endTime=None): _str_func = 'PostBake.bakeTempLocator' if startTime is None: startTime = self.startTime if endTime is None: endTime = self.endTime ct = mc.currentTime(q=True) self._bakedLoc = cgmMeta.asMeta(LOC.create(name='bakeLoc')) self._bakedLoc.rotateOrder = self.obj.rotateOrder SNAP.matchTarget_set(self._bakedLoc.mNode, self.obj.mNode) _len = endTime - startTime _progressBar = cgmUI.doStartMayaProgressBar(_len, "Processing...") _obj = VALID.objString(self._bakedLoc.mNode, noneValid=False) _target = VALID.objString( self.obj.mNode, noneValid=False ) #ATTR.get_message(_obj, 'cgmMatchTarget','cgmMatchDat',0) ak = mc.autoKeyframe(q=True, state=True) mc.autoKeyframe(state=False) mc.refresh(su=True) completed = True for i in range(startTime, endTime + 1): mc.currentTime(i) SNAP.go(_obj, _target, True, True, pivot='rp') mc.setKeyframe(_obj, at=['translate', 'rotate']) if _progressBar: if mc.progressBar(_progressBar, query=True, isCancelled=True): log.warning('Bake cancelled!') completed = False break mc.progressBar(_progressBar, edit=True, status=("{0} On frame {1}".format(_str_func, i)), step=1, maxValue=_len) mc.refresh(su=False) mc.autoKeyframe(state=ak) cgmUI.doEndMayaProgressBar(_progressBar) mc.currentTime(ct) return completed
def __func__(self): """ """ obj = cgmValid.objString(self.d_kws['obj'],isTransform=True) crv = cgmValid.objString(self.d_kws['crv'],mayaType='nurbsCurve') d_returnBuff = distance.returnNearestPointOnCurveInfo(obj,crv) mi_poci = cgmMeta.cgmNode(nodeType = 'pointOnCurveInfo') mc.connectAttr("%s.worldSpace"%d_returnBuff['shape'],"%s.inputCurve"%mi_poci.mNode) mi_poci.parameter = d_returnBuff['parameter'] mc.connectAttr("%s.position"%mi_poci.mNode,"%s.t"%obj) mi_poci.doStore('cgmName',obj) mi_poci.doName() return True
def _fncStep_dataCheck_(self): #Key to object name dict _d_stuffToFind = {'headModule':'head_part', 'neckModule':'neck_part', 'l_eyeModule':'l_eye_part', 'r_eyeModule':'r_eye_part', 'headMasterAnim':'Head_masterAnim', 'headPuppet':'Head_puppetNetwork', 'BodyPuppet':'MK1_puppetNetwork', 'faceGui':'facialRig_gui_grp', 'faceCam':'faceCam', 'world_eyeLook':'world_driving_head_eyeLook_dynDriver', 'world_leftEye':'world_driving_right_eye_ik_dynDriver', 'world_rightEye':'world_driving_left_eye_ik_dynDriver', 'SDKface':'face_attrHolder', 'SDKcustomize':'sdk_custom_attrHolder', 'joint_bodyHead':'head_jnt', 'joint_faceRigHead':'headRoot_jnt', 'ik_eyes':'head_eyeLook_anim', 'ik_l_eye':'l_eye_ik_anim', 'ik_r_eye':'r_eye_ik_anim', 'ik_shoulders':'shoulders_ik_anim', 'ik_cog':'cog_anim', } self.md_objs = {} for k in _d_stuffToFind.keys(): _obj = cgmValid.objString(arg=_d_stuffToFind[k], noneValid=True, calledFrom=self._str_funcName) if not _obj: return self._FailBreak_("key: {0} | name: ('{1}') | missing".format(k,_d_stuffToFind[k])) self.md_objs[k] = cgmMeta.cgmNode(_obj) self.log_info("'{0}' found".format(k)) self.log_infoNestedDict('md_objs')
def test_falseIfNotObjExistsAndNoneValid(self): self.assertFalse( validateArgs.objString(arg="does_not_exist", noneValid=True), "validateArgs.objString did not return false when the object "+\ "did not exist and noneValid was set to True" )
def offsetShape_byVector(dag=None, distance=1, origin=None, component='cv', vector=None, mode='origin', factor=.5, offsetMode='fixed'): """ Attempt for more consistency If origin is None, juse the center of each shape """ _str_func = 'offsetShape_byVector' log.debug( "|{0}| >> dag: {1} | distance: {2} | origin: {3} | component: {4}". format(_str_func, dag, distance, origin, component)) _originUse = None if VALID.isListArg(origin): _originUse = origin elif VALID.objString(origin, noneValid=True): log.debug( "|{0}| >> Getting origin from transform of origin string: {1}". format(_str_func, origin)) _originUse = POS.get(origin) if VALID.is_shape(dag): l_shapes = [dag] else: l_shapes = mc.listRelatives(dag, shapes=True, fullPath=True) for i, s in enumerate(l_shapes): log.debug("|{0}| >> On shape: {1}".format(_str_func, s)) if _originUse is None: #_trans = VALID.getTransform(dag) _origin = POS.get_bb_center(s) log.debug("|{0}| >> Getting origin from center of s: {1}".format( _str_func, _origin)) else: _origin = _originUse _l_source = mc.ls("{0}.{1}[*]".format(s, component), flatten=True, long=True) for ii, c in enumerate(_l_source): log.debug("|{0}| >> Shape {1} | Comp: {2} | {3}".format( _str_func, i, ii, c)) if offsetMode == 'fixed': set_vectorOffset(c, _origin, distance, vector, mode=mode) else: pMe = POS.get(c) _vec = MATHUTILS.get_vector_of_two_points(_origin, pMe) d = get_distance_between_points(_origin, pMe) newPos = get_pos_by_vec_dist(POS.get(c), _vec, d * factor) POS.set(c, newPos) return True
def position(target = None, infoDict = None, move = True, rotate = True): """ Get data for updating a loc :parameters target(str): What to use for updating our loc :returns info(dict) """ _str_func = "position" _target = VALID.objString(target, noneValid=True, calledFrom = __name__ + _str_func + ">> validate target") pos = infoDict['position'] if move: mc.move (pos[0],pos[1],pos[2], _target, ws=True) if rotate: if infoDict.get('rotateOrder'):mc.xform(_target, roo=infoDict['rotateOrder'],p=True) if infoDict.get('rotation'):mc.xform(_target, ro=infoDict['rotation'], ws = True) if infoDict.get('rotateAxis'):mc.xform(_target, ra=infoDict['rotateAxis'],p=True) #mTarget = r9Meta.getMObject(target) mc.xform(_target, rp=infoDict['position'], ws = True, p=True) if infoDict.get('scalePivot'):mc.xform(_target, sp=infoDict['scalePivot'], ws = True, p=True) #Rotate #if infoDict['objectType'] == 'polyFace': #constBuffer = mc.normalConstraint((locInfo['createdFrom']),locatorName) #mc.delete(constBuffer[0]) return True
def test_falseIfNotObjExistsAndNoneValid(self): self.assertFalse( validateArgs.objString(arg="does_not_exist", noneValid=True), "validateArgs.objString did not return false when the object "+\ "did not exist and noneValid was set to True" )
def aim_atMidPoint(obj = None, targets = None, aimAxis = "z+", upAxis = "y+",mode='local',vectorUp = None): """ Aim functionality. :parameters: obj(str): Object to modify target(str): object to copy from aimAxis(str): axis that is pointing forward upAxis(str): axis that is pointing up vectorUp(vector): Only relevent during vector mode mode(str): 'local'-- use standard maya aiming with local axis 'world' -- use standard maya aiming with world axis 'matrix' -- use Bokser's fancy method 'vector' -- maya standard with vector up axis :returns success(bool) """ _str_func = 'aimAtMidpoint' _obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj") _targets = VALID.objStringList(targets, noneValid=False, calledFrom = __name__ + _str_func + ">> validate targets") targetPos = MATH.Vector3.zero() for t in _targets: targetPos += MATH.Vector3.Create(POS.get(t)) targetPos /= len(_targets) aim_atPoint(_obj, MATH.Vector3.AsArray(targetPos), aimAxis, upAxis,mode = mode,vectorUp=vectorUp)
def test_falseIfWrongMayaTypeNoneValid(self): self.assertFalse( validateArgs.objString( arg=self.maya_obj, mayaType='plusMinusAverage', noneValid=True ) )
def test_passIfRightMayaType(self): self.assertEquals( validateArgs.objString( arg=self.maya_obj, mayaType='multiplyDivide' ), self.maya_obj )
def test_passIfIsTransform(self): self.assertTrue( validateArgs.objString( arg=self.maya_obj, isTransform=True ), self.maya_obj )
def test_falseIfNotTransformNoneValid(self): print "test_falseIfNotTransformNoneValid" self.assertFalse( validateArgs.objString( arg=self.nonTransform, isTransform=True, noneValid=True ) )
def matchTarget_set(obj = None, target = None): """ Set the match target of an object :parameters: obj(str): Object to modify target(str): Target to match :returns success(bool) """ _str_func = 'matchTarget_set' _obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj") _target = VALID.objString(target, noneValid=False, calledFrom = __name__ + _str_func + ">> validate target") ATTR.set_message(_obj, 'cgmMatchTarget',_target,'cgmMatchDat',0) return True
def get_createSize(arg=None, mode=None): """ Attempt to find a good size for control creation or :parameters: arg(str/list): Object(s) to check :returns boundingBox size(list) """ def is_resGood(res=None): if MATHUTILS.is_float_equivalent(res, 0.000) or res == -2e+20: return False return True _str_func = 'get_createSize' _arg = VALID.objString(arg, noneValid=False, calledFrom=_str_func) log.debug("|{0}| >> arg: '{1}' ".format(_str_func, _arg)) _bb_max = get_bb_size(_arg, True, True) log.debug("|{0}| >> bbSize: {1} ".format(_str_func, _bb_max)) if not MATHUTILS.is_float_equivalent(_bb_max, 0.000) and not _bb_max == -2e+20: return _bb_max log.debug("|{0}| >> Zero boundingBox object...".format(_str_func)) _children = mc.listRelatives(_arg, children=True, type='transform') or False if _children: _closestChild = get_by_dist(_arg, _children, 'close', 'object') log.debug("|{0}| >> closest child mode. | closest: {1} ".format( _str_func, _closestChild)) _res = get_distance_between_points(POS.get(_arg), POS.get(_closestChild)) if is_resGood(_res): return _res log.debug("|{0}| >> child mode fail...".format(_str_func)) _parent = mc.listRelatives(_arg, parent=True, type='transform') or False if _parent: log.debug("|{0}| >> Parent mode...".format(_str_func)) _res = get_distance_between_points(POS.get(_arg), POS.get(_parent)) if is_resGood(_res): return _res log.debug("|{0}| >> Parent mode fail...".format(_str_func)) raise RuntimeError, "Shouldn't have gotten here. Failed at finding value"
def matchTarget_snap(obj=None, move=True, rotate=True, boundingBox=False, pivot='rp'): """ Snap an object to it's match target :parameters: obj(str): Object to modify target(str): Target to match :returns success(bool) """ _str_func = 'matchTarget_snap' _obj = VALID.objString(obj, noneValid=False, calledFrom=__name__ + _str_func + ">> validate obj") _target = ATTR.get_message(_obj, 'cgmMatchTarget', 'cgmMatchDat', 0) if not _target: raise ValueError, "|{0}| >> {1} has no cgmMatchTarget.".format( _str_func, NAMES.get_short(_obj)) log.debug("|{0}| >> {1} snapping to: {2}.".format(_str_func, NAMES.get_short(_obj), _target[0])) go(obj, _target[0], move, rotate, pivot=pivot) return True _dict = POS.get_info(_target[0]) #cgmGEN.log_info_dict(_dict) pos = _dict['position'] if move: mc.move(pos[0], pos[1], pos[2], _obj, ws=True, rpr=True) if rotate: #if _dict.get('rotateOrder'):mc.xform(_obj, roo=_dict['rotateOrder'],p=True) if _dict.get('rotation'): mc.xform(_obj, ro=_dict['rotation'], ws=True) #if _dict.get('rotateAxis'):mc.xform(_obj, ra=_dict['rotateAxis'],p=True) return True
def verify_aimAttrs(obj=None, aim=None, up=None, checkOnly=False): """ Make sure an object has aim attributes. :parameters: obj(str): Object to modify aim(arg): Value to set with on call up(arg): Value to set with on call out(arg): Value to set with on call checkOnly(bool): Check only, no adding attrs :returns success(bool) """ _str_func = 'verify_aimAttrs' _str_enum = 'x+:y+:z+:x-:y-:z-' _obj = VALID.objString(obj, noneValid=False, calledFrom=__name__ + _str_func + ">> validate obj") _l = [aim, up] _l_defaults = [aim or 2, up or 1] for i, a in enumerate(['axisAim', 'axisUp']): _d = ATTR.validate_arg(_obj, a) _good = False if mc.objExists(_d['combined']): if ATTR.get_type(_d) == 'enum': if ATTR.get_enum(_d) == _str_enum: _good = True if not _good: if checkOnly: return False log.debug("|{0}| >> {1} not a good attr. Must rebuild".format( _str_func, _d['combined'])) ATTR.delete(_d) ATTR.add(_d, 'enum', enumOptions=_str_enum, hidden=False) ATTR.set(_d, value=_l_defaults[i]) ATTR.set_keyable(_d, False) _v = _l[i] if _v is not None: ATTR.set(_d, value=_v) return True
def matchTarget_clear(obj = None): """ Clear the match target of an object :parameters: obj(str): Object to modify :returns success(bool) """ _str_func = 'matchTarget_set' _obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj") ATTR.delete(_obj,'cgmMatchTarget') ATTR.delete(_obj,'cgmMatchDat') return True
def get_info(target=None, boundingBox=False): """ Get data for updating a transform :parameters target(str): What to use for updating our loc :returns info(dict) """ _str_func = "get_info" _target = VALID.objString(target, noneValid=True, calledFrom=__name__ + _str_func + ">> validate target") _posPivot = 'rp' if boundingBox: _posPivot = 'boundingBox' _transform = VALID.getTransform(target) log.debug("|{0}| >> Target: {1} | tranform: {2}".format( _str_func, _target, _transform)) _d = {} _d['createdFrom'] = _target _d['objectType'] = VALID.get_mayaType(_target) _d['position'] = get(target, _posPivot, 'world') _d['translate'] = get(target, _posPivot, 'local') _d['scalePivot'] = get(_transform, 'sp', 'world') _d['rotation'] = mc.xform(_transform, q=True, ws=True, ro=True) _d['rotateOrder'] = mc.xform(_transform, q=True, roo=True) _d['rotateAxis'] = mc.xform(_transform, q=True, os=True, ra=True) _d['rotateLocal'] = mc.xform(_transform, q=True, os=True, ro=True) #cgmGen.log_info_dict(_d,'|{0}.{1}| info...'.format(__name__,_str_func)) return _d
def get_normalized_uv(mesh, uValue, vValue): """ uv Values from many functions need to be normalized to be correct when using those values for other functions The calculcaion for doing so is size = maxV - minV sum = rawV + minV normalValue = sum / size :parameters: mesh(string) | Surface to normalize to uValue(float) | uValue to normalize vValue(float) | vValue to normalize :returns Dict ------------------------------------------------------------------ 'uv'(double2) | point from which we cast 'uValue'(float) | normalized uValue 'vValue'(float) | normalized vValue :raises: Exception | if reached """ _str_func = 'get_normalized_uv' try: try: #Validation ---------------------------------------------------------------- reload(VALID) _mesh = VALID.objString(mesh, 'nurbsSurface', calledFrom=_str_func) #log.debug("|{0}| >> mesh arg: {1} | validated: {2}".format(_str_func,mesh,_mesh)) if not SEARCH.is_shape(_mesh): shape = mc.listRelatives(_mesh, shapes=True)[0] log.debug( "|{0}| >> Transform provided. using first shape: {1}". format(_str_func, shape)) else: shape = _mesh uMin = ATTR.get(shape, 'mnu') uMax = ATTR.get(shape, 'mxu') vMin = ATTR.get(shape, 'mnv') vMax = ATTR.get(shape, 'mxv') """uMin = mi_shape.mnu uMax = mi_shape.mxu vMin = mi_shape.mnv vMax = mi_shape.mxv""" except Exception, error: raise Exception, "Validation failure | {0}".format(error) try: #Calculation ---------------------------------------------------------------- uSize = uMax - uMin vSize = vMax - vMin uSum = uMin + uValue vSum = vMin + vValue uNormal = uSum / uSize vNormal = vSum / vSize except Exception, error: raise Exception, "Calculation |{0}".format(error)
else: log.error("|{0}| >> unknown mode: {1}".format(_str_func, _mode)) return False try: return position(**_kws) except Exception, err: log.error("|{0}| >> loc: {1}".format(_str_func, loc)) cgmGeneral.log_info_dict(_kws['infoDict'], "{0} >> {1}".format(_str_func, mode)) log.error("|{0}| >> err: {1}".format(_str_func, _err)) return False _str_func = "update" _loc = VALID.objString(loc, noneValid=True, calledFrom=__name__ + _str_func + ">> validate loc") _type = VALID.get_mayaType(_loc) _targets = VALID.listArg(targets) if _type == 'locator': if mode and _targets: log.debug("|{0}| >> mode override...".format(_str_func)) return getAndMove(_loc, _targets, mode, forceBBCenter) elif _targets: log.debug("|{0}| >> source mode...".format(_str_func)) if len(_targets) > 1: log.debug("|{0}| >> assuming midPoint...".format(_str_func))
def _fnc_processInfluenceMode(self): ''' Sort out the joint data If joitn list is passed, try to use that, if not, Try skin cluster on target, cluster on source ''' _mode = self._influenceMode _l_configInfluenceList = self.get_ConfigJointList()#...get our config influence list self.l_configInfluenceList = _l_configInfluenceList#...store it _len_configList = len(_l_configInfluenceList) _targetMesh = self.mData.d_target['mesh'] #...See if we have a skin cluster... _targetSkin = skinning.querySkinCluster(_targetMesh) or False if _mode == 'config': _l_jointTargets = _l_configInfluenceList elif _mode == 'list': _l_joints = self.d_kws.get('jointList') if not _l_joints: return self._FailBreak_("jointList kw required. '{0}' influenceMode".format(_mode)) if not cgmValid.isListArg(_l_joints): return self._FailBreak_("jointList is not a list. '{0}' influenceMode".format(_mode)) if len(_l_joints) != len(_l_configInfluenceList): return self._FailBreak_("Non matching counts on target influences({0}) and config data({1}) | Cannot use '{2}' influenceMode".format(len(_l_joints),len(_l_configInfluenceList),_mode)) _l_jointTargets = _l_joints elif _mode == 'target': if not _targetSkin: return self._FailBreak_("Target mesh not skinned, cannot use '{0}' influenceMode".format(_mode)) _l_targetInfluences = mc.listConnections(_targetSkin+'.matrix') or [] if len(_l_targetInfluences) != len(_l_configInfluenceList): #for i,jnt in enumerate(_l_configInfluenceList): #try:_bfr = _l_targetInfluences[i] #except: # _bfr = False #self.log_info("{0} | Config: {1} | target: {2}".format(i,jnt,_bfr)) if self._b_addMissingInfluences: self._b_case_addMissingInfluences = True#...set our case else: return self._FailBreak_("Non matching counts on target influences({0}) and config data({1}) | Cannot use '{2}' influenceMode".format(len(_l_targetInfluences),len(_l_configInfluenceList),_mode)) _l_jointTargets = _l_targetInfluences elif _mode == 'source': if not self.mData.d_source: return self._FailBreak_("No source data found, cannot use '{0}' influenceMode".format(_mode)) _sourceSkin = skinning.querySkinCluster(self.mData.d_source['mesh']) or False _l_sourceInfluences = mc.listConnections(_sourceSkin+'.matrix') or [] if len(_l_sourceInfluences) != len(_l_configInfluenceList): return self._FailBreak_("Non matching counts on source influences({0}) and config data({1}) | Cannot use '{2}' influenceMode".format(len(_l_sourceInfluences),len(_l_configInfluenceList),_mode)) _l_jointTargets = _l_sourceInfluences if self._b_case_addMissingInfluences:#Missing Influence Add... self.log_info("addMissingInfluencesAttempt... "+ cgmGeneral._str_subLine) if _len_configList < len(_l_jointTargets): self.log_warning("More targetJoints({0}) than config joints({1}). Not implemented".format(len(_l_jointTargets),_len_configList)) else: _d = {} for i,v in enumerate(_l_jointTargets):_d[i] = v#...push stuff to a list for i,jnt in enumerate(_l_configInfluenceList): try:_bfr = _l_jointTargets[i] except: _l_search = [jnt, self.mData.d_sourceSkin['matrix'][i]] self.log_info("{0} | Config: {1} | missing joint. Attempting to find: {2}".format(i,jnt,_l_search)) for o in _l_search: foundJnt = cgmValid.objString(o, mayaType = _validObjTypes, noneValid=True)#...mayaType = 'joint', if foundJnt: _d[i] = foundJnt self._l_missingInfluences.append(foundJnt) self.log_info("Found {0}".format(foundJnt)) break return self._FailBreak_("{0} | Not able to fo find joint ({1})".format(i,jnt)) #...push back to our list _l_jointTargets = [] for i in range(_len_configList):_l_jointTargets.append(False) for i,v in _d.iteritems(): _l_jointTargets[i] = v #self.log_info("{0} | Config: {1} | target: {2}".format(i,jnt,_bfr)) #self.log_info("Joints to use....") #for i,j in enumerate(_l_jointsToUse): #self.log_info("{0} : {1} | config idxed to: {2}".format(i,j,_l_configInfluenceList[i])) #...see if they exist with no conflicts #_l_jointTargets = l_dataJoints#...this will change try:_l_jointsToUse = cgmValid.objStringList(_l_jointTargets,mayaType = _validObjTypes)#...mayaType = 'joint' except Exception,Error:return self._FailBreak_("influenceMode '{0}' joint check fail | {1}".format(_mode,Error)) self.l_jointsToUse = _l_jointsToUse
def test_falseIfNotTransformNoneValid(self): print "test_falseIfNotTransformNoneValid" self.assertFalse( validateArgs.objString(arg=self.nonTransform, isTransform=True, noneValid=True))
def test_passIfIsTransform(self): self.assertTrue( validateArgs.objString(arg=self.maya_obj, isTransform=True), self.maya_obj)
def returnNormalizedUV(mesh, uValue, vValue): """ uv Values from many functions need to be normalized to be correct when using those values for other functions The calculcaion for doing so is size = maxV - minV sum = rawV + minV normalValue = sum / size :parameters: mesh(string) | Surface to normalize to uValue(float) | uValue to normalize vValue(float) | vValue to normalize :returns: Dict ------------------------------------------------------------------ 'uv'(double2) | point from which we cast 'uValue'(float) | normalized uValue 'vValue'(float) | normalized vValue :raises: Exception | if reached """ try: _str_funcName = 'returnNormalizedUV' try:#Validation ---------------------------------------------------------------- mesh = cgmValid.objString(mesh,'nurbsSurface', calledFrom = _str_funcName) if len(mc.ls(mesh))>1: raise StandardError,"{0}>>> More than one mesh named: {1}".format(_str_funcName,mesh) _str_objType = search.returnObjectType(mesh) l_shapes = mc.listRelatives(mesh, shapes=True) if len(l_shapes)>1: log.debug( "More than one shape found. Using 0. targetSurface : %s | shapes: %s"%(mesh,l_shapes) ) mi_shape = cgmMeta.validateObjArg(l_shapes[0],cgmMeta.cgmNode,noneValid=False) uMin = mi_shape.mnu uMax = mi_shape.mxu vMin = mi_shape.mnv vMax = mi_shape.mxv except Exception,error:raise Exception,"Validation failure | {0}".format(error) try:#Calculation ---------------------------------------------------------------- uSize = uMax - uMin vSize = vMax - vMin uSum = uMin + uValue vSum = vMin + vValue uNormal = uSum / uSize vNormal = vSum / vSize except Exception,error:raise Exception,"Calculation |{0}".format(error) try: d_return = {'uv':[uNormal,vNormal],'uValue':uNormal,'vValue':vNormal} return d_return except Exception,error:raise Exception,"Return prep |{0}".format(error) except Exception,error: log.error(">>> {0} >> Failure! mesh: '{1}' | uValue: {2} | vValue {3}".format(_str_funcName,mesh,uValue,vValue)) log.error(">>> {0} >> error: {1}".format(_str_funcName,error)) return None
def _fnc_processInfluenceMode(self): ''' Sort out the joint data If joitn list is passed, try to use that, if not, Try skin cluster on target, cluster on source ''' _mode = self._influenceMode _l_configInfluenceList = self.get_ConfigJointList()#...get our config influence list self.l_configInfluenceList = _l_configInfluenceList#...store it _len_configList = len(_l_configInfluenceList) _targetMesh = self.mData.d_target['mesh'] #...See if we have a skin cluster... _targetSkin = skinning.querySkinCluster(_targetMesh) or False if _mode == 'config': _l_jointTargets = _l_configInfluenceList elif _mode == 'list': _l_joints = self.d_kws.get('jointList') if not _l_joints: return self._FailBreak_("jointList kw required. '{0}' influenceMode".format(_mode)) if not cgmValid.isListArg(_l_joints): return self._FailBreak_("jointList is not a list. '{0}' influenceMode".format(_mode)) if len(_l_joints) != len(_l_configInfluenceList): return self._FailBreak_("Non matching counts on target influences({0}) and config data({1}) | Cannot use '{2}' influenceMode".format(len(_l_joints),len(_l_configInfluenceList),_mode)) _l_jointTargets = _l_joints elif _mode == 'target': if not _targetSkin: return self._FailBreak_("Target mesh not skinned, cannot use '{0}' influenceMode".format(_mode)) _l_targetInfluences = mc.listConnections(_targetSkin+'.matrix') or [] if len(_l_targetInfluences) != len(_l_configInfluenceList): #for i,jnt in enumerate(_l_configInfluenceList): #try:_bfr = _l_targetInfluences[i] #except: # _bfr = False #self.log_info("{0} | Config: {1} | target: {2}".format(i,jnt,_bfr)) if self._b_addMissingInfluences: self._b_case_addMissingInfluences = True#...set our case else: return self._FailBreak_("Non matching counts on target influences({0}) and config data({1}) | Cannot use '{2}' influenceMode".format(len(_l_targetInfluences),len(_l_configInfluenceList),_mode)) _l_jointTargets = _l_targetInfluences elif _mode == 'source': if not self.mData.d_source: return self._FailBreak_("No source data found, cannot use '{0}' influenceMode".format(_mode)) _sourceSkin = skinning.querySkinCluster(self.mData.d_source['mesh']) or False _l_sourceInfluences = mc.listConnections(_sourceSkin+'.matrix') or [] if len(_l_sourceInfluences) != len(_l_configInfluenceList): return self._FailBreak_("Non matching counts on source influences({0}) and config data({1}) | Cannot use '{2}' influenceMode".format(len(_l_sourceInfluences),len(_l_configInfluenceList),_mode)) _l_jointTargets = _l_sourceInfluences if self._b_case_addMissingInfluences:#Missing Influence Add... self.log_info("addMissingInfluencesAttempt... "+ cgmGeneral._str_subLine) if _len_configList < len(_l_jointTargets): self.log_warning("More targetJoints({0}) than config joints({1}). Not implemented".format(len(_l_jointTargets),_len_configList)) else: _d = {} for i,v in enumerate(_l_jointTargets):_d[i] = v#...push stuff to a list for i,jnt in enumerate(_l_configInfluenceList): try:_bfr = _l_jointTargets[i] except: _l_search = [jnt, self.mData.d_sourceSkin['matrix'][i]] self.log_info("{0} | Config: {1} | missing joint. Attempting to find: {2}".format(i,jnt,_l_search)) for o in _l_search: foundJnt = cgmValid.objString(o, mayaType = _validObjTypes, noneValid=True)#...mayaType = 'joint', if foundJnt: _d[i] = foundJnt self._l_missingInfluences.append(foundJnt) self.log_info("Found {0}".format(foundJnt)) break return self._FailBreak_("{0} | Not able to fo find joint ({1})".format(i,jnt)) #...push back to our list _l_jointTargets = [] for i in range(_len_configList):_l_jointTargets.append(False) for i,v in _d.iteritems(): _l_jointTargets[i] = v #self.log_info("{0} | Config: {1} | target: {2}".format(i,jnt,_bfr)) #self.log_info("Joints to use....") #for i,j in enumerate(_l_jointsToUse): #self.log_info("{0} : {1} | config idxed to: {2}".format(i,j,_l_configInfluenceList[i])) #...see if they exist with no conflicts #_l_jointTargets = l_dataJoints#...this will change try:_l_jointsToUse = cgmValid.objStringList(_l_jointTargets,mayaType = _validObjTypes)#...mayaType = 'joint' except Exception,Error:return self._FailBreak_("influenceMode '{0}' joint check fail | {1}".format(_mode,Error)) self.l_jointsToUse = _l_jointsToUse
def test_passIfRightMayaType(self): self.assertEquals( validateArgs.objString(arg=self.maya_obj, mayaType='multiplyDivide'), self.maya_obj)
def get_by_dist(source=None, targets=None, mode='close', resMode='point', sourcePivot='rp', targetPivot='rp'): """ Get the the closest return based on a source and target and variable modes :parameters: :source(str): Our base object to measure from :targets(list): List of object types :mode(str):What mode are we checking data from close far :resMode(str): object -- return the [closest] target point -- return the [closest] point #component -- return [the closest] base component pointOnSurface -- [closest] point on the target shape(s) pointOnSurfaceLoc -- [closest] point on target shape(s) Loc'd shape -- gets closest point on every shape, returns closest resMode(str) :returns [res,distance] """ def get_fromTargets(sourcePos, targets, targetPivot, resMode, mode): _l_distances = [] _l_pos = [] for t in targets: _tarPos = POS.get(t, targetPivot, space='world') _l_pos.append(_tarPos) _d = get_distance_between_points(sourcePos, _tarPos) log.debug( "|{0}| >> target: {1} | pivot: {4} | dist: {3} | pos: {2}...| mode: {5}" .format(_str_func, t, _tarPos, _d, targetPivot, mode)) _l_distances.append(_d) if mode == 'close': _minDist = min(_l_distances) _minIdx = _l_distances.index(_minDist) if resMode == 'point': return _l_pos[_minIdx], _minDist return targets[_minIdx], _minDist else: _maxDist = max(_l_distances) _maxIdx = _l_distances.index(_maxDist) if resMode == 'point': return _l_pos[_maxIdx], _maxDist return targets[_maxIdx], _maxDist _d_by_dist_modes = { 'close': ['closest', 'c', 'near'], 'far': ['furthest', 'long'] } _str_func = 'get_by_dist' _source = VALID.objString(source, noneValid=False, calledFrom=__name__ + _str_func + ">> validate targets") _mode = VALID.kw_fromDict(mode, _d_by_dist_modes, noneValid=False, calledFrom=__name__ + _str_func + ">> validate mode") _resMode = resMode _l_targets = VALID.objStringList(targets, noneValid=False, calledFrom=__name__ + _str_func + ">> validate targets") _sourcePivot = VALID.kw_fromDict(sourcePivot, SHARED._d_pivotArgs, noneValid=False, calledFrom=__name__ + _str_func + ">> validate sourcePivot") _targetPivot = VALID.kw_fromDict(targetPivot, SHARED._d_pivotArgs, noneValid=False, calledFrom=__name__ + _str_func + ">> validate targetPivot") log.debug("|{0}| >> source: {1} | mode:{2} | resMode:{3}".format( _str_func, _source, _mode, _resMode)) #Source============================================================== _sourcePos = POS.get(_source, _sourcePivot, space='ws') log.debug("|{0}| >> Source pos({2}): {1}...".format( _str_func, _sourcePos, _sourcePivot)) #Modes if _resMode in ['object', 'point']: log.debug("|{0}| >> object resMode...".format(_str_func)) mc.select(cl=True) _res = get_fromTargets(_sourcePos, _l_targets, _targetPivot, _resMode, _mode) if resMode == 'object': mc.select(_res[0]) return _res[0] return _res[0] elif _resMode == 'component': raise NotImplementedError, "component mode" elif _resMode in ['pointOnSurface', 'shape', 'pointOnSurfaceLoc']: log.debug("|{0}| >> Shape processing...".format(_str_func)) #Targets============================================================= log.debug("|{0}| >> Targets processing...".format(_str_func)) _d_targetTypes = {} _l_pos = [] _l_dist = [] _l_shapes = [] """for t in _l_targets: _t = t _bfr_component = VALID.get_component(t) if _bfr_component: _t = _bfr_component[1]#...shape _type = VALID.get_mayaType(_t) if _type not in _d_targetTypes.keys(): _d_targetTypes[_type] = [_t] else: _d_targetTypes[_type].append(_t) log.debug("|{0}| >> obj: {1} | type: {2}".format(_str_func,t,_type))""" #cgmGen.log_info_dict(_d_targetTypes,'Targets to type') for t in _l_targets: res = get_closest_point(_sourcePos, t) if not res: log.error("|{0}| >> {1} -- failed".format(_str_func, t)) else: log.debug("|{0}| >> {1}: {2}".format(_str_func, t, res)) _l_pos.append(res[0]) _l_dist.append(res[1]) _l_shapes.append(res[2]) if not _l_dist: log.error("|{0}| >> Failed to find any points".format(_str_func)) return False closest = min(_l_dist) _idx = _l_dist.index(closest) if _resMode == 'pointOnSurfaceLoc': _loc = mc.spaceLocator(n='get_by_dist_loc')[0] POS.set(_loc, _l_pos[_idx]) return _loc if _resMode == 'shape': mc.select(_l_shapes[_idx]) return _l_shapes[_idx] return _l_pos[_idx]
def aim_atPoint(obj = None, position = [0,0,0], aimAxis = "z+", upAxis = "y+", mode = 'local',vectorUp = None,ignoreAimAttrs = False): """ Aim functionality. :parameters: obj(str): Object to modify position(array): object to copy from aimAxis(str): axis that is pointing forward upAxis(str): axis that is pointing up mode(str): 'local'-- use standard maya aiming with local axis 'world' -- use standard maya aiming with world axis 'matrix' -- use Bokser's fancy method 'vector' -- maya standard with vector up axis 'object' -- maya standard with object :returns success(bool) """ try: _str_func = 'aimAtPoint' _loc = False _obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj") try:position = position.x,position.y,position.z except:pass try:vectorUp = vectorUp.x,vectorUp.y,vectorUp.z except:pass log.debug("|{0}| >> obj: {1} | position:{2} | mode: {3}".format(_str_func,_obj,position,mode)) if not ignoreAimAttrs: _d_aim = ATTR.validate_arg(_obj,'axisAim') _d_up =ATTR.validate_arg(_obj,'axisUp') if ATTR.has_attr(_d_aim) and ATTR.has_attr(_d_up): aimAxis = ATTR.get_enumValueString(_d_aim) upAxis = ATTR.get_enumValueString(_d_up) log.debug("|{0}| >> obj: {1} aimable from attrs. aim: {2} | up: {3}".format(_str_func,_obj,aimAxis,upAxis)) if mode == 'matrix': '''Rotate transform based on look vector''' # get source and target vectors objPos = POS.get(_obj, asEuclid=True) targetPos = MATH.Vector3.Create(position) aim = (targetPos - objPos).normalized() if not vectorUp: upVector = MATH.Vector3.up() if upAxis == "y-": upVector = MATH.Vector3.down() elif upAxis == "z+": upVector = MATH.Vector3.forward() elif upAxis == "z-": upVector = MATH.Vector3.back() elif upAxis == "x+": upVector = MATH.Vector3.right() elif upAxis == "x-": upVector = MATH.Vector3.left() else: upVector = MATH.Vector3.up() vectorUp = MATH.transform_direction( _obj, upVector ) wantedAim, wantedUp = MATH.convert_aim_vectors_to_different_axis(aim, vectorUp, aimAxis, upAxis) xformPos = mc.xform(_obj, q=True, matrix = True, ws=True) pos = MATH.Vector3(xformPos[12], xformPos[13], xformPos[14]) rot_matrix = EUCLID.Matrix4.new_look_at(MATH.Vector3.zero(), -wantedAim, wantedUp) s = MATH.Vector3.Create( mc.xform(_obj, q=True, ws=True, s=True) ) scale_matrix = EUCLID.Matrix4() scale_matrix.a = s.x scale_matrix.f = s.y scale_matrix.k = s.z scale_matrix.p = 1 result_matrix = rot_matrix * scale_matrix transform_matrix = result_matrix[0:12] + [pos.x, pos.y, pos.z, 1.0] mc.xform(_obj, matrix = transform_matrix , roo="xyz", ws=True) """elif mode == 'world': _loc = mc.spaceLocator()[0] mc.move (position[0],position[1],position[2], _loc, ws=True) mAxis_aim = VALID.simpleAxis(aimAxis) mAxis_up = VALID.simpleAxis(upAxis) _constraint = mc.aimConstraint(_loc,_obj, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'scene',) mc.delete(_constraint + [_loc])""" elif mode in ['local','world','vector','object']: _loc = mc.spaceLocator(name='test')[0] _loc_snap = POS.create_loc(_obj) mc.move (position[0],position[1],position[2], _loc, ws=True) mAxis_aim = VALID.simpleAxis(aimAxis) mAxis_up = VALID.simpleAxis(upAxis) if mode == 'world': _constraint = mc.aimConstraint(_loc,_loc_snap, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'scene',) elif mode == 'object': vectorUp = VALID.mNodeString(vectorUp) _constraint = mc.aimConstraint(_loc,_loc_snap, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'object', worldUpObject = vectorUp) #worldUpVector = _vUp) else: if mode == 'vector': _vUp = vectorUp else: _vUp = MATH.get_obj_vector(_obj,upAxis) _constraint = mc.aimConstraint(_loc,_loc_snap, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'vector', worldUpVector = _vUp) go(obj,_loc_snap) mc.delete(_constraint,_loc_snap) else: raise NotImplementedError,"mode: {0}".format(mode) if _loc:mc.delete(_loc) return True except Exception,err: try:mc.delete(_loc) except:pass log.error( "aim_atPoint | obj: {0} | err: {1}".format(obj,err) )
def test_falseIfWrongMayaTypeNoneValid(self): self.assertFalse( validateArgs.objString(arg=self.maya_obj, mayaType='plusMinusAverage', noneValid=True))