def get_rigGeo(self):
"""
First pass on qss verification
"""
_str_func = 'get_rigGeo'
log.debug("|{0}| >> ...".format(_str_func) + cgmGEN._str_hardBreak)
log.debug(self)
mMasterNull = self.masterNull
_res = []
_l_base = [o for o in mc.ls(type='mesh', visible=True, long=True)]
_l_dags = [VALID.getTransform(o) for o in _l_base]
_l_dags = LISTS.get_noDuplicates(_l_dags)
for o in _l_dags:
mObj = cgmMeta.asMeta(o)
if mObj.getMayaAttr('mClass') == 'cgmControl':
log.debug("|{0}| >> Invalid obj: {1}".format(_str_func, o))
continue
if mObj.getMayaAttr('cgmType') in [
'jointApprox', 'rotatePlaneVisualize'
]:
log.debug("|{0}| >> Invalid obj: {1}".format(_str_func, o))
continue
if 'proxy_geo' in o:
continue
if 'proxyGeo' in o:
continue
_res.append(mObj)
log.debug("|{0}| >> Visible shapes: {1} | dags: {2} | res: {3} ".format(
_str_func, len(_l_base), len(_l_dags), len(_res)))
return _res
def create_distanceMeasure(start=None, end=None, baseName='measure'):
"""
Get the the closest return based on a source and target and variable modes
:parameters:
:start(str): Our start obj
:end(str): End obj
:baseName(str):What mode are we checking data from
:returns
{shape,dag,loc_start,loc_end,start,end}
"""
try:
_str_func = 'create_distanceMeasure'
#Create ====================================================================================
plug_start = POS.get_positionPlug(start)
plug_end = POS.get_positionPlug(end)
_res = {'start': start, 'end': end}
if not plug_start:
pos_start = POS.get(start)
loc_start = mc.spaceLocator(name="{0}_{1}_start_loc".format(
NAMES.get_base(start), baseName))[0]
POS.set(loc_start, pos_start)
plug_start = POS.get_positionPlug(loc_start)
_res['loc_start'] = loc_start
if not plug_end:
pos_end = POS.get(end)
loc_end = mc.spaceLocator(name="{0}_{1}_end_loc".format(
NAMES.get_base(end), baseName))[0]
POS.set(loc_end, pos_end)
plug_end = POS.get_positionPlug(loc_end)
_res['loc_end'] = loc_end
mDistShape = r9Meta.MetaClass(mc.createNode('distanceDimShape'))
mDistShape.rename("{0}_distShape".format(baseName))
mDistTrans = r9Meta.MetaClass(VALID.getTransform(mDistShape.mNode))
mDistTrans.rename("{0}_dist".format(baseName))
_res['dag'] = mDistTrans.mNode
_res['shape'] = mDistShape.mNode
ATTR.set_message(_res['dag'], 'distShape', _res['shape'], simple=True)
ATTR.connect(plug_start, "{0}.startPoint".format(_res['shape']))
ATTR.connect(plug_end, "{0}.endPoint".format(_res['shape']))
return _res
except Exception, err:
cgmGen.cgmExceptCB(Exception, err)
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 create_localAxisProxyBAK(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_localAxisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node"
l_shapes = TRANS.shapes_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#_dup = TRANS.parent_set(_dup,False)
#Get some values...
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
TRANS.orient_set(_dup, (0, 0, 0))
ATTR.set(_dup, 'scale', [1, 1, 1])
_size = POS.get_bb_size(_dup, True)
import cgm.core.lib.math_utils as COREMATH
reload(COREMATH)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
return
#mc.xform(_proxy, scale = _size, worldSpace = True, absolute = True)
#Parent it to the dup...
_proxy = TRANS.parent_set(_proxy, _dup)
ATTR.reset(_proxy, ['t', 'r', 'shear'])
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
ATTR.set(_dup, 'shear', shear)
#TRANS.scaleLocal_set(_dup, s)
#mc.delete(_dup)
#_scaleLossy = TRANS.scaleLossy_get(_dag)
#import cgm.core.lib.math_utils as COREMATH
#TRANS.scaleLocal_set(_dup, COREMATH.list_mult([-1.0,-1.0,-1.0],_scaleLossy,))
#proxy = TRANS.parent_set(_proxy, False)
cgmGEN.func_snapShot(vars())
#ATTR.set(_dup,'translate',t)
#ATTR.set(_dup,'rotate',r)
#SNAP.go(_proxy[0],_dag)
#ATTR.set(_proxy[0],'scale',_scaleLossy)
#TRANS.scaleLocal_set(_dup,[1,1,1])
#ATTR.set(_dup,'shear',[0,0,0])
#_proxy = TRANS.parent_set(_proxy, False)
#TRANS.scaleLocal_set(_proxy,_scaleLossy)
#ATTR.set(_dup,'scale',s)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def create_axisProxy(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_axisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node. Obj: {0}".format(obj)
if VALID.is_shape(obj):
l_shapes = [obj]
else:
l_shapes = TRANS.shapes_get(_dag, True)
_parent = TRANS.parent_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#TRANS.pivots_recenter(_dup)
_dup = TRANS.parent_set(_dup, False)
ATTR.set_standardFlags(_dup, lock=False, keyable=True)
#Get some values...
l_reset = ['t', 'r', 's', 'shear', 'rotateAxis']
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
ra = ATTR.get(_dup, 'rotateAxis')
if ATTR.has_attr(_dup, 'jointOrient'):
l_reset.append('jointOrient')
jo = ATTR.get(_dup, 'jointOrient')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
ATTR.reset(_dup, l_reset)
_size = POS.get_bb_size(_dup, True)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
#Now Put it back
_dup = TRANS.parent_set(_dup, TRANS.parent_get(_dag))
_proxy = TRANS.parent_set(_proxy, _dup)
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
#ATTR.set(_dup,'s',(0,0,0))
ATTR.reset(_dup, ['s', 'shear'])
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
_proxy = TRANS.parent_set(_proxy, _dag)
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
#match_transform(_proxy,_dag)
#SNAP.go(_proxy,_dag,pivot='bb')
#cgmGEN.func_snapShot(vars())
_proxy = TRANS.parent_set(_proxy, False)
mc.delete(_dup)
#match_transform(_proxy,_dag)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def get_axisBox_size(arg=None, children=False, mode=None, asEuclid=False):
"""
Get the bb size of a given arg
:parameters:
arg(str/list): Object(s) to check
shapes(bool): Only check dag node shapes
mode(varied):
True/'max': Only return max value
'min': Only min
:returns
boundingBox size(list)
"""
_str_func = 'get_axisBox_size'
#_arg = VALID.stringListArg(arg,False,_str_func)
try:
log.debug("|{0}| >> shapes mode ".format(_str_func))
arg = VALID.listArg(arg)
_dag = VALID.getTransform(arg[0])
if not _dag:
raise ValueError, "Must have a dag node. Obj: {0}".format(_dag)
if VALID.is_shape(_dag):
l_shapes = [_dag]
else:
l_shapes = mc.listRelatives(_dag, s=True, fullPath=True) or []
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
if not children:
for o in mc.listRelatives(
_dup, children=True, type='transform',
fullPath=True) or []:
mc.delete(o)
try:
_dup = mc.parent(_dup, world=True)[0]
except:
pass
#Reset our stuff before we make our bb...
ATTR.reset(_dup, ['t', 'r', 'shear'])
_size = get_bb_size(_dup, True)
mc.delete(_dup)
_res = _size
if mode is None:
if asEuclid:
log.debug("|{0}| >> asEuclid...".format(_str_func))
return EUCLID.Vector3(_res[0], _res[1], _res[2])
return _res
elif mode in [True, 'max']:
return max(_res)
elif mode in ['min']:
return min(_res)
else:
log.error("|{0}| >> Unknown mode. Returning default. {1} ".format(
_str_func, mode))
return _res
except Exception, err:
cgmGen.cgmExceptCB(Exception, err, msg=vars())
