def alongLine(objList=None, mode='even', curve='linear', spans=2):
"""
Arrange a list of objects evenly along a vector from first to last
:parameters:
objList(list): objects to layout
mode(string)
'even' - evenly distributed along line
'spaced' - distribute along line as close as possible to current position
:returns
list of constraints(list)
"""
_str_func = 'onLine'
objList = VALID.mNodeStringList(objList)
log.info("|{0}| >> ObjList: {1} ".format(_str_func, objList))
_len = len(objList)
if _len < 3:
raise ValueError, "|{0}| >> Need at least 3 objects".format(_str_func)
_pos_start = POS.get(objList[0])
_pos_end = POS.get(objList[-1])
curveBuffer = []
if curve == 'linear':
if mode != 'even':
curveBuffer = mc.curve(d=1, ep=[_pos_start, _pos_end])
elif curve in ['cubic', 'cubicRebuild']:
l_pos = [POS.get(o) for o in objList]
knot_len = len(l_pos) + 3 - 1
crv1 = mc.curve(d=3,
ep=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
curveBuffer = [crv1]
if curve == 'cubicRebuild':
curveBuffer.append(
mc.rebuildCurve(crv1,
ch=0,
rpo=0,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=spans,
d=3,
tol=0.001)[0])
elif curve == 'cubicArc':
_mid = MATH.get_midIndex(_len)
log.info("|{0}| >> cubicArc | mid: {1} ".format(_str_func, _mid))
l_pos = [POS.get(o) for o in [objList[0], objList[_mid], objList[-1]]]
knot_len = len(l_pos) + 3 - 1
curveBuffer = mc.curve(d=3,
ep=l_pos,
k=[i for i in range(0, knot_len)],
os=True)
else:
raise ValueError, "|{0}| >>unknown curve setup: {1}".format(
_str_func, curve)
if mode == 'even':
if curve == 'linear':
_vec = MATH.get_vector_of_two_points(_pos_start, _pos_end)
_offsetDist = DIST.get_distance_between_points(
_pos_start, _pos_end) / (_len - 1)
_l_pos = [
DIST.get_pos_by_vec_dist(_pos_start, _vec, (_offsetDist * i))
for i in range(_len)
]
log.info("|{0}| >> offset: {1} ".format(_str_func, _offsetDist))
log.info("|{0}| >> l_pos: {1} ".format(_str_func, _l_pos))
for i, o in enumerate(objList[1:-1]):
POS.set(o, _l_pos[i + 1])
else:
_l_pos = CURVES.getUSplitList(curveBuffer, points=_len, rebuild=1)
for i, o in enumerate(objList[1:-1]):
POS.set(o, _l_pos[i + 1])
elif mode == 'spaced':
_l_pos = []
for i, o in enumerate(objList[1:-1]):
#SNAP.go(o,curveBuffer,pivot= 'closestPoint')
p = DIST.get_by_dist(o, curveBuffer, resMode='pointOnSurface')
POS.set(o, p)
_l_pos.append(p)
else:
try:
raise ValueError, "{0} >> mode not supported: {1}".format(
sys._getframe().f_code.co_name, mode)
except:
raise ValueError, "mode not supported: {0}".format(mode)
if curveBuffer:
mc.delete(curveBuffer)
return _l_pos
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])