def get_surfaceSplitCurves(surface=None,
l_values=[],
count=None,
mode='u',
offset=None,
cullStartEnd=True):
_str_func = 'get_surfaceSplitCurves'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_shape = SHAPES.get_nonintermediate(surface)
if mode == 'u':
l_base = get_dat(_shape, uKnots=True)['uKnots']
minKnot = ATTR.get(_shape, 'minValueU')
maxKnot = ATTR.get(_shape, 'maxValueU')
else:
l_base = get_dat(_shape, vKnots=True)['vKnots']
minKnot = ATTR.get(_shape, 'minValueV')
maxKnot = ATTR.get(_shape, 'maxValueV')
if count is not None:
l_values = MATH.get_splitValueList(minKnot,
maxKnot,
count,
cullStartEnd=cullStartEnd)
res = []
for v in l_values:
crv = get_shapeCurve(_shape, v, mode, offset=offset)
res.append(crv)
return res
def get_splitValues(surface=None,
values=[],
mode='u',
knotIndices=[],
insertMin=False,
insertMax=False,
preInset=None,
postInset=None,
offset=None,
curvesCreate=False,
curvesConnect=False,
connectionPoints=9):
"""
Function to split a curve up u positionally
:parameters:
'curve'(None) -- Curve to split
curvesCreate(bool) - create new curves from the new values
curvesConnect(bool) - whether to connect the first and last curves
connectionPoints(int) - how many points of connection to use
:returns
list of values(list)
hat tip: http://ewertb.soundlinker.com/mel/mel.074.php
"""
_str_func = 'get_splitValues'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_shape = SHAPES.get_nonintermediate(surface)
if mode == 'u':
l_base = get_dat(_shape, uKnots=True)['uKnots']
minKnot = ATTR.get(_shape, 'minValueU')
maxKnot = ATTR.get(_shape, 'maxValueU')
else:
l_base = get_dat(_shape, vKnots=True)['vKnots']
minKnot = ATTR.get(_shape, 'minValueV')
maxKnot = ATTR.get(_shape, 'maxValueV')
l_sets = []
log.debug("|{0}| >> l_base: {1}".format(_str_func, l_base))
if knotIndices:
values = [l_base[v] for v in knotIndices]
for i, v in enumerate(values):
log.debug("|{0}| >> Processing: {1} | {2}".format(_str_func, i, v) +
"-" * 40)
_last = False
if v == values[-1]:
log.debug("|{0}| >> last...".format(_str_func))
_last = True
if preInset:
v += preInset
log.debug("|{0}| >> preinset: {1}".format(_str_func, v))
_l = [v]
_stop = False
for knot in l_base:
if _stop or MATH.is_float_equivalent(knot, v) == v: continue
log.debug("|{0}| >> checking knot: {1}".format(_str_func, knot))
if _last:
if knot > v:
_stop = True
_l.append(knot)
if knot > v or knot < v:
if _last != True and knot < values[i + 1] and knot > v:
_l.append(knot)
log.debug("|{0}| >> knot add: {1}".format(_str_func, _l))
"""
if v == values[-1]:
if knot < maxKnot:
_l.append(knot)
elif _last != True and knot < values[i+1]:
_l.append(knot)"""
if _last and insertMax:
l_add = []
for v2 in l_base:
if v2 > _l[-1]:
l_add.append(v2)
for v2 in l_add:
_l.append(v2)
_l.append(maxKnot)
if _last != True:
_l.append(values[i + 1])
if insertMin and i == 0:
_l.insert(0, minKnot)
if postInset:
vPost = _l[-1] + postInset
if vPost < _l[-2]:
log.debug("|{0}| >> alternate postInset".format(_str_func))
vPost = _l[-2] + postInset
log.debug("|{0}| >> postInset: {1} | new: {2}".format(
_str_func, _l[-1], vPost))
if len(_l) > 1:
if vPost > max(_l[:-1]):
log.debug(
"|{0}| >> v post creater the max".format(_str_func))
_l[-1] = vPost
else:
_l = _l[:-1]
else:
_l.append(vPost)
"""
if _last != True:
for v2 in _l:
if v2 > v:
_l.remove(v2)"""
_l = LISTS.get_noDuplicates(_l)
_l.sort()
l_sets.append(_l)
log.debug("|{0}| >> result: {1} | {2} | {3}".format(
_str_func, i, v, _l))
l_pre = copy.copy(l_sets)
#pprint.pprint(vars())
if not curvesCreate:
return l_sets
log.debug("|{0}| >> creating curves...".format(_str_func))
l_newCurves = []
d_curves = {}
l_finalCurves = []
def getCurve(uValue, l_newCurves):
_crv = d_curves.get(uValue)
if _crv: return _crv
_crv = mc.duplicateCurve("{0}.u[{1}]".format(_shape, uValue),
ch=0,
rn=0,
local=0)[0]
if offset:
DIST.offsetShape_byVector(_crv, offset, component='cv')
d_curves[uValue] = _crv
log.debug("|{0}| >> created: {1} ...".format(_str_func, _crv))
l_newCurves.append(_crv)
return _crv
for i, uSet in enumerate(l_sets):
_loftCurves = [getCurve(uValue, l_newCurves) for uValue in uSet]
"""
if len(uSet)<2:
l_finalCurves.append(mc.duplicate(_loftCurves[0])[0])
continue"""
log.debug("|{0}| >> {1} | u's: {2}".format(_str_func, i, uSet))
"""
if i == 0 and str_start:
_pair = [str_start,c,l_newCurves[i+1]]
else:
_pair = [c,l_newCurves[i+1]]"""
if len(_loftCurves) == 1:
l_mainCurves = [mc.duplicate(_loftCurves[0])[0]]
else:
crvBase = mc.duplicate(_loftCurves[0])[0]
crvEnd = mc.duplicate(_loftCurves[-1])[0]
l_mainCurves = [crvBase, crvEnd]
if curvesConnect:
log.debug("|{0}| >> {1} | Making connectors".format(
_str_func, i))
d_epPos = {}
for i, crv in enumerate(_loftCurves):
_l = CURVES.getUSplitList(crv,
connectionPoints,
rebuild=True,
rebuildSpans=30)[:-1]
for ii, p in enumerate(_l):
if not d_epPos.get(ii):
d_epPos[ii] = []
_l = d_epPos[ii]
_l.append(p)
for k, points in d_epPos.iteritems():
log.debug("|{0}| >> {1} | k: {1} | points: {2}".format(
_str_func, k, points))
try:
crv_connect = mc.curve(d=1, ep=points, os=True)
#CURVES.create_fromList(posList=points)
l_mainCurves.append(crv_connect)
except Exception, err:
print err
for crv in l_mainCurves[1:]:
CORERIG.shapeParent_in_place(l_mainCurves[0], crv, False)
#ml_shapes.append(cgmMeta.validateObjArg(l_mainCurves[0]))
l_finalCurves.append(l_mainCurves[0])
def attach_toShape(obj = None, targetShape = None, connectBy = 'parent'):
"""
:parameters:
obj - transform to attach
targetShape(str) - Curve, Nurbs, Mesh
connectBy(str)
parent - parent to track transform
parentGroup - parent to group and have group follow
conPoint - just point contraint
conPointGroup - pointConstrain group
conPointOrientGroup - point/orient constrain group
conParentGroup - parent Constrain group
None - just the tracker nodes
:returns:
resulting dat
"""
try:
_str_func = 'attach_toShape'
mObj = cgmMeta.validateObjArg(obj,'cgmObject')
targetShape = VALID.mNodeString(targetShape)
log.debug("targetShape: {0}".format(targetShape))
#Get our data...
d_closest = DIST.get_closest_point_data(targetShape,
mObj.mNode)
log.debug("|{0}| >> jnt: {1} | {2}".format(_str_func,mObj.mNode, d_closest))
#pprint.pprint(d_closest)
if d_closest['type'] in ['mesh','nurbsSurface']:
log.debug("|{0}| >> Follicle mode...".format(_str_func))
_shape = SHAPES.get_nonintermediate(d_closest['shape'] )
log.debug("_shape: {0}".format(_shape))
l_follicleInfo = NODES.createFollicleOnMesh( _shape )
i_follicleTrans = cgmMeta.asMeta(l_follicleInfo[1],'cgmObject',setClass=True)
i_follicleShape = cgmMeta.asMeta(l_follicleInfo[0],'cgmNode')
#> Name...
i_follicleTrans.doStore('cgmName',mObj)
i_follicleTrans.doStore('cgmTypeModifier','surfaceTrack')
i_follicleTrans.doName()
_trackTransform = i_follicleTrans.mNode
#>Set follicle value...
if d_closest['type'] == 'mesh':
i_follicleShape.parameterU = d_closest['parameterU']
i_follicleShape.parameterV = d_closest['parameterV']
else:
i_follicleShape.parameterU = d_closest['normalizedU']
i_follicleShape.parameterV = d_closest['normalizedV']
_res = [i_follicleTrans.mNode, i_follicleShape.mNode]
else:
log.debug("|{0}| >> Curve mode...".format(_str_func))
#d_returnBuff = distance.returnNearestPointOnCurveInfo(obj,crv)
_shape = SHAPES.get_nonintermediate(d_closest['shape'] )
mPOCI = cgmMeta.cgmNode(nodeType = 'pointOnCurveInfo')
mc.connectAttr("%s.worldSpace"%_shape,"%s.inputCurve"%mPOCI.mNode)
mPOCI.parameter = d_closest['parameter']
mTrack = mObj.doCreateAt()
mTrack.doStore('cgmName',mObj)
mTrack.doStore('cgmType','surfaceTrack')
mTrack.doName()
_trackTransform = mTrack.mNode
mc.connectAttr("%s.position"%mPOCI.mNode,"%s.t"%_trackTransform)
mPOCI.doStore('cgmName',mObj)
mPOCI.doName()
_res = [mTrack.mNode, mPOCI.mNode]
if connectBy is None:
return _res
elif connectBy == 'parent':
mObj.p_parent = _trackTransform
return _res
elif connectBy == 'conPoint':
mc.pointConstraint(_trackTransform, mObj.mNode,maintainOffset = True)
return _res
elif connectBy == 'conParent':
mc.parentConstraint(_trackTransform, mObj.mNode,maintainOffset = True)
return _res
elif connectBy == 'parentGroup':
mGroup = mObj.doGroup(asMeta=True)
#_grp = TRANS.group_me(obj,True)
#TRANS.parent_set(_grp,_trackTransform)
mGroup.p_parent = _trackTransform
return _res + [mGroup.mNode]
elif connectBy == 'conPointGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode,mGroup.mNode)
return _res + [mGroup.mNode]
elif connectBy == 'conPointOrientGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode,mGroup.mNode)
mc.orientConstraint(mLoc.mNode,mGroup.mNode)
return _res + [mGroup.mNode]
elif connectBy == 'conParentGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.parentConstraint(mLoc.mNode,mGroup.mNode)
return _res + [mGroup.mNode]
else:
raise NotImplementedError,"|{0}| >>invalid connectBy: {1}".format(_str_func,connectBy)
#pprint.pprint(vars())
except Exception,err:cgmGEN.cgmExceptCB(Exception,err)
def attach_toShape(obj=None,
targetShape=None,
connectBy='parent',
driver=None):
"""
:parameters:
obj - transform to attach
targetShape(str) - Curve, Nurbs, Mesh
connectBy(str)
parent - parent to track transform
parentGroup - parent to group and have group follow
conPoint - just point contraint
conPointGroup - pointConstrain group
conPointOrientGroup - point/orient constrain group
conParentGroup - parent Constrain group
None - just the tracker nodes
:returns:
resulting dat
"""
try:
_str_func = 'attach_toShape'
mObj = cgmMeta.validateObjArg(obj, 'cgmObject')
mDriver = cgmMeta.validateObjArg(driver, 'cgmObject', noneValid=True)
targetShape = VALID.mNodeString(targetShape)
log.debug("targetShape: {0}".format(targetShape))
#Get our data...
d_closest = DIST.get_closest_point_data(targetShape, mObj.mNode)
log.debug("|{0}| >> jnt: {1} | {2}".format(_str_func, mObj.mNode,
d_closest))
#pprint.pprint(d_closest)
md_res = {}
if d_closest['type'] in ['mesh', 'nurbsSurface']:
log.debug("|{0}| >> Follicle mode...".format(_str_func))
_shape = SHAPES.get_nonintermediate(d_closest['shape'])
log.debug("_shape: {0}".format(_shape))
l_follicleInfo = NODES.createFollicleOnMesh(_shape)
i_follicleTrans = cgmMeta.asMeta(l_follicleInfo[1],
'cgmObject',
setClass=True)
i_follicleShape = cgmMeta.asMeta(l_follicleInfo[0], 'cgmNode')
#> Name...
i_follicleTrans.doStore('cgmName', mObj)
i_follicleTrans.doStore('cgmTypeModifier', 'surfaceTrack')
i_follicleTrans.doName()
_trackTransform = i_follicleTrans.mNode
#>Set follicle value...
if d_closest['type'] == 'mesh':
i_follicleShape.parameterU = d_closest['parameterU']
i_follicleShape.parameterV = d_closest['parameterV']
else:
i_follicleShape.parameterU = d_closest['normalizedU']
i_follicleShape.parameterV = d_closest['normalizedV']
_res = [i_follicleTrans.mNode, i_follicleShape.mNode]
md_res['mFollicle'] = i_follicleTrans
md_res['mFollicleShape'] = i_follicleShape
else:
log.debug("|{0}| >> Curve mode...".format(_str_func))
#d_returnBuff = distance.returnNearestPointOnCurveInfo(obj,crv)
_shape = SHAPES.get_nonintermediate(d_closest['shape'])
mPOCI = cgmMeta.cgmNode(nodeType='pointOnCurveInfo')
mc.connectAttr("%s.worldSpace" % _shape,
"%s.inputCurve" % mPOCI.mNode)
mPOCI.parameter = d_closest['parameter']
mTrack = mObj.doCreateAt()
mTrack.doStore('cgmName', mObj)
mTrack.doStore('cgmType', 'surfaceTrack')
mTrack.doName()
_trackTransform = mTrack.mNode
mc.connectAttr("%s.position" % mPOCI.mNode,
"%s.t" % _trackTransform)
mPOCI.doStore('cgmName', mObj)
mPOCI.doName()
_res = [mTrack.mNode, mPOCI.mNode]
if mDriver:
if d_closest['type'] in ['nurbsSurface']:
mFollicle = i_follicleTrans
mFollShape = i_follicleShape
minU = ATTR.get(_shape, 'minValueU')
maxU = ATTR.get(_shape, 'maxValueU')
minV = ATTR.get(_shape, 'minValueV')
maxV = ATTR.get(_shape, 'maxValueV')
mDriverLoc = mDriver.doLoc()
mc.pointConstraint(mDriver.mNode, mDriverLoc.mNode)
#mLoc = mObj.doLoc()
str_baseName = "{0}_to_{1}".format(mDriver.p_nameBase,
mObj.p_nameBase)
mPlug_normalizedU = cgmMeta.cgmAttr(
mDriverLoc.mNode,
"{0}_normalizedU".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_sumU = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_sumU".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_normalizedV = cgmMeta.cgmAttr(
mDriverLoc.mNode,
"{0}_normalizedV".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_sumV = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_sumV".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
#res_closest = DIST.create_closest_point_node(mLoc.mNode, mCrv_reparam.mNode,True)
log.debug("|{0}| >> Closest info {1}".format(_str_func, _res))
srfNode = mc.createNode('closestPointOnSurface')
mc.connectAttr("%s.worldSpace[0]" % _shape,
"%s.inputSurface" % srfNode)
mc.connectAttr("%s.translate" % mDriverLoc.mNode,
"%s.inPosition" % srfNode)
#mc.connectAttr("%s.position" % srfNode, "%s.translate" % mLoc.mNode, f=True)
#mClosestPoint = cgmMeta.validateObjArg(srfNode,setClass=True)
#mClosestPoint.doStore('cgmName',mObj)
#mClosestPoint.doName()
log.debug("|{0}| >> paramU {1}.parameterU | {2}".format(
_str_func, srfNode, ATTR.get(srfNode, 'parameterU')))
log.debug("|{0}| >> paramV {1}.parameterV | {2}".format(
_str_func, srfNode, ATTR.get(srfNode, 'parameterV')))
l_argBuild = []
mPlug_uSize = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_uSize".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_vSize = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_vSize".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
l_argBuild.append("{0} = {1} - {2}".format(
mPlug_vSize.p_combinedName, maxV, minV))
l_argBuild.append("{0} = {1} - {2}".format(
mPlug_uSize.p_combinedName, maxU, minU))
l_argBuild.append("{0} = {1} + {2}.parameterU".format(
mPlug_sumU.p_combinedName, minU, srfNode))
l_argBuild.append("{0} = {1} / {2}".format(
mPlug_normalizedU.p_combinedName,
mPlug_sumU.p_combinedName, mPlug_uSize.p_combinedName))
l_argBuild.append("{0} = {1} + {2}.parameterV".format(
mPlug_sumV.p_combinedName, minV, srfNode))
l_argBuild.append("{0} = {1} / {2}".format(
mPlug_normalizedV.p_combinedName,
mPlug_sumV.p_combinedName, mPlug_vSize.p_combinedName))
for arg in l_argBuild:
log.debug("|{0}| >> Building arg: {1}".format(
_str_func, arg))
NODEFACTORY.argsToNodes(arg).doBuild()
ATTR.connect(mPlug_normalizedU.p_combinedShortName,
'{0}.parameterU'.format(mFollShape.mNode))
ATTR.connect(mPlug_normalizedV.p_combinedShortName,
'{0}.parameterV'.format(mFollShape.mNode))
md_res['mDriverLoc'] = mDriverLoc
elif d_closest['type'] in ['curve', 'nurbsCurve']:
mDriverLoc = mDriver.doLoc()
mc.pointConstraint(mDriver.mNode, mDriverLoc.mNode)
_resClosest = DIST.create_closest_point_node(
mDriverLoc.mNode, _shape, True)
_loc = _resClosest[0]
md_res['mDriverLoc'] = mDriverLoc
md_res['mDrivenLoc'] = cgmMeta.asMeta(_loc)
md_res['mTrack'] = mTrack
else:
log.warning(
cgmGEN.logString_msg(
_str_func,
"Shape type not currently supported for driver setup. Type: {0}"
.format(d_closest['type'])))
#if connectBy is None:
#return _res
if connectBy == 'parent':
mObj.p_parent = _trackTransform
elif connectBy == 'conPoint':
mc.pointConstraint(_trackTransform,
mObj.mNode,
maintainOffset=True)
elif connectBy == 'conParent':
mc.parentConstraint(_trackTransform,
mObj.mNode,
maintainOffset=True)
elif connectBy == 'parentGroup':
mGroup = mObj.doGroup(asMeta=True)
#_grp = TRANS.group_me(obj,True)
#TRANS.parent_set(_grp,_trackTransform)
mGroup.p_parent = _trackTransform
_res = _res + [mGroup.mNode]
elif connectBy == 'conPointGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy == 'conPointOrientGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode, mGroup.mNode)
mc.orientConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy == 'conParentGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.parentConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy is None:
pass
else:
raise NotImplementedError, "|{0}| >>invalid connectBy: {1}".format(
_str_func, connectBy)
if md_res:
return _res, md_res
return _res
#pprint.pprint(vars())
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)