def select_deselect_edge_lists(root_edge, loop=True):
kw = {'edgeLoop' if loop else 'edgeRing': root_edge.index}
if root_edge in mampy.complist():
kw.update({'deselect': True})
else:
kw.update({'add': True})
cmds.polySelect(root_edge.dagpath, **kw)
def edgeLoopsToCurve(edgeList,form=2,degree=1):
'''
Generate edge loop curves from the specified list of edges.
@param edgeList: The list of mesh edges to generate edge loop curves from.
@type edgeList: list
@param form: NURBS curve form. 0 = Periodic, 1 = Open, 2 = Best Guess.
@type form: str
@param degree: NURBS curve degree.
@type degree: str
'''
# Filter/Check Edge List
edgeList = mc.filterExpand(edgeList,ex=True,sm=32)
if not edgeList: raise Exception('Invalid edge list!')
# For Each Edge
edgeCurveList = []
for edge in edgeList:
# Get Mesh
edgeId = glTools.utils.component.index(edge)
meshShape = mc.ls(edge,o=True)[0]
mesh = mc.listRelatives(meshShape,p=True)[0]
prefix = mesh.split(':')[-1]
# To Edge Loop
mc.polySelect(mesh,edgeLoop=edgeId)
# Edge Loop to Curve
edgeCurve = mc.polyToCurve(ch=False,form=form,degree=degree)[0]
# Append List
edgeCurveList.append(edgeCurve)
# Return Result
return edgeCurveList
def edgeLoopWeights(edgeList):
"""
"""
# Check Edge List
if not edgeList: raise Exception('Invalid or empty edge list!')
edgeList = cmds.filterExpand(edgeList, ex=True, sm=32) or []
if not edgeList: raise Exception('Invalid edge list! List of polygon edges required...')
# Get Mesh from Edges
mesh = list(set(cmds.ls(edgeList, o=True) or []))
if len(mesh) > 1:
raise Exception('Edges from multiple mesh shapes were supplied! ' + str(mesh))
mesh = mesh[0]
for edge in edgeList:
# Get Edge ID
edgeID = glTools.utils.component.index(edge)
# Get Vertices from Edge
edgeVerts = cmds.polyListComponentConversion(edge, fe=True, tv=True)
# Get Average Vertex Weights
cmds.select(edgeVerts)
glTools.tools.copyPasteWeights.averageWeights()
# Select Edge Loop Vertices
cmds.polySelect(mesh, edgeLoop=edgeID)
loopEdges = cmds.ls(sl=1, fl=1)
loopVerts = cmds.polyListComponentConversion(loopEdges, fe=True, tv=True)
cmds.select(loopVerts)
glTools.tools.copyPasteWeights.pasteWeights()
# Return Result
return mesh
def inbetween():
"""Select components between the last two selections."""
# TODO: refactor and finish.
ordered_selection = mampy.complist(os=True)
if not len(ordered_selection) % 2 == 0:
comp1, comp2 = ordered_selection[-2:]
else:
for comp in ordered_selection:
cmds.polySelect(comp.cmdslist(), q=True, loop=True)
def main():
#get edge IDs
curSel = mc.ls(sl=1,fl=1)
edgeID = []
for str in curSel:
edgeID.append(int(re.split('[]]',(re.split('[[]',str)[1]))[0]))
#print(edgeID)
# check if loop
edgeLoopGp = mc.polySelect(el=edgeID[0],q=1)
if len(edgeLoopGp)>1:
loopLst = []
for edge in edgeLoopGp:
edge = repr(edge)
if edge.find(repr(edgeID[1]))==0:
loopLst.append(edge)
isEL = len(loopLst)
else:
isEL = 0
# check if ring
edgeRingGp = mc.polySelect(er=edgeID[0],q=1)
if len(edgeRingGp)>1:
RingLst = []
for edge in edgeRingGp:
edge = repr(edge)
if edge.find(repr(edgeID[1]))==0:
RingLst.append(edge)
isER = len(RingLst)
else:
isER = 0
# check if border
edgeBorderGp = mc.polySelect(eb=edgeID[0],q=1)
if type(edgeBorderGp) is ListType:
if len(edgeBorderGp)>1:
BorderLst = []
for edge in edgeBorderGp:
edge = repr(edge)
if edge.find(repr(edgeID[1]))==0:
BorderLst.append(edge)
isBd = len(BorderLst)
else:
isBd = 0
#do pattern
if isEL==1:
# edge loop pattern
mc.polySelect(lpt=(edgeID[0],edgeID[1]))
elif isER==1:
#edge ring pattern
mc.polySelect(rpt=(edgeID[0],edgeID[1]))
elif isBd==1:
#edge ring pattern
mc.polySelect(bpt=(edgeID[0],edgeID[1]))
def is_border(self, index):
"""
Check if component index is on border of mesh.
"""
if self.type == api.MFn.kMeshPolygonComponent:
return self.mesh.onBoundary(index)
elif self.type == api.MFn.kMeshEdgeComponent:
return cmds.polySelect(self.dagpath, q=True, edgeBorder=index, ns=True) or False
else:
edge = self.new().add(index).to_edge()
return any(
[cmds.polySelect(self.dagpath, q=True, edgeBorder=i, ns=True) for i in edge.indices]
)
return False
def doIt(self, argList):
# get only the first object from argument list
try:
obj = misc.getArgObj(self.syntax(), argList)[0]
except:
cmds.warning("No object selected!")
return
if (cmds.objectType(obj) != 'transform'):
cmds.error("Object is not of type transform!")
return
# get parser object and use (optional) progress string as reference to UI-text to show current progress of calculation
argData = om.MArgParser (self.syntax(), argList)
progress = argData.flagArgumentString('progress', 0) if (argData.isFlagSet('progress')) else ""
simplices = misc.getTriangles(obj)
# save each shell in nested loop with indices to objects faces
shells = []
shell_indices = []
# save a list of booleans to indicate if tri already belongs to a found shell
triInShell = [False]*len(simplices)
# remember number of triangles already in one shell (to show progress)
count = 0
# loop over shells until each facet is mapped to one shell
while len(shell_indices) < len(simplices):
try:
# get indices of all faces connected to given face (smallest index not used yet)
# method ".index" will raise an exception if element is not found --> all triangles are in one shell --> break
shell_indices = cmds.polySelect(obj, ets = triInShell.index(False), noSelection = 1)
except:
break
# append shell indices to nested list structure (to remember which indices belong to which shell)
#shells.append(shell_indices)
shells.append(cmds.polySelect(obj, ets = triInShell.index(False), noSelection = 1, ass = 1))
# set indices in boolean list to True
for s in shell_indices:
triInShell[s] = True
count += len(shell_indices)
# update progress in text field (percentage of triangles already in found shells)
try:
cmds.text(progress, e = 1, label = 'Processing... (' + "{0:.1f}%)".format(float(count)/len(simplices) * 100) ) + '%%)'
cmds.refresh(f = 1)
except:
pass
# set result (string representation of each shell's indices list)
for s in shells:
self.appendToResult(str(s))
def getShells(self, obj):
"""
@param[in] obj: object full name
@type obj: string
@returns: list of shells that is included in the passed in object in format [ [[obj.f[0], obj.f[1], obj.f[2]], [obj.f[3], obj.f[4], obj.f[5]], [another shell]], [another object]]
"""
output = []
# total data
numOfShells = cmds.polyEvaluate(obj, s=1)
faceList = cmds.ls(cmds.polyListComponentConversion(obj, tf=True), l=1, fl=1)
for i in range(numOfShells):
# cmds.select(obj)
idx = int(faceList[0].split(".f[")[-1].split("]")[0])
shellFaces = cmds.polySelect(obj, q=1, ets=idx)
shellFacesFormat = [] # obj.f[0], obj.f[1] ...
if shellFaces:
for j in shellFaces:
__faceData = obj + ".f[" + str(j) + "]"
shellFacesFormat.append(__faceData)
faceList = self.comprehensionList(faceList, shellFacesFormat)
output.append(shellFacesFormat)
return output
def select_deselect_border_edge(root_edge, tolerance):
def get_vector_from_edge(edge, index):
p1, p2 = [edge.points[i] for i in edge.vertices[index]]
return p2 - p1
root_edge_vector = get_vector_from_edge(root_edge, root_edge.index)
edge_border_indices = cmds.polySelect(
root_edge.dagpath,
edgeBorder=root_edge.index,
noSelection=True
)
border_edge = root_edge.new().add(edge_border_indices)
edges_to_select = root_edge.new()
for idx in border_edge:
border_edge_vector = get_vector_from_edge(border_edge, idx)
if root_edge_vector.isParallel(border_edge_vector, tolerance):
edges_to_select.add(idx)
connected = edges_to_select.get_connected_components()
for e in connected:
if root_edge.index in e:
if root_edge in mampy.complist():
cmds.select(e.cmdslist(), d=True)
else:
cmds.select(e.cmdslist(), add=True)
def dfs(control_set, start):
seen, stack = set(), [start]
while stack:
index = stack.pop()
if index not in seen:
shell = cmds.polySelect(str(self.dagpath), q=True, ets=index, ns=True)
seen.update(shell)
stack.extend(control_set - seen)
yield shell
def getPolyShells(self, mesh):
# returns poly shells as lists of faces
shells = []
polygons = [i for i in range(0, cmds.polyEvaluate(f=1))]
for poly in polygons:
faces = cmds.polySelect(mesh, ets=poly, q=1)
shells.append(faces)
for face in faces:
polygons.pop(polygons.index(face))
return shells
def edgeLoopWeights(edgeList):
'''
'''
# Check Edge List
if not edgeList: raise Exception('Invalid or empty edge list!')
edgeList = mc.filterExpand(edgeList, ex=True, sm=32) or []
if not edgeList:
raise Exception('Invalid edge list! List of polygon edges required...')
# Get Mesh from Edges
mesh = list(set(mc.ls(edgeList, o=True) or []))
if len(mesh) > 1:
raise Exception('Edges from multiple mesh shapes were supplied! ' +
str(mesh))
mesh = mesh[0]
for edge in edgeList:
# Get Edge ID
edgeID = glTools.utils.component.index(edge)
# Get Vertices from Edge
edgeVerts = mc.polyListComponentConversion(edge, fe=True, tv=True)
# Get Average Vertex Weights
mc.select(edgeVerts)
glTools.tools.copyPasteWeights.averageWeights()
# Select Edge Loop Vertices
mc.polySelect(mesh, edgeLoop=edgeID)
loopEdges = mc.ls(sl=1, fl=1)
loopVerts = mc.polyListComponentConversion(loopEdges, fe=True, tv=True)
mc.select(loopVerts)
glTools.tools.copyPasteWeights.pasteWeights()
# Return Result
return mesh
def getMiddleEdgeByMiddleVerts(self, middVerts):
middleEdgeArray = []
for mea in middVerts:
edgeLoop = cmds.polySelect(self.polyName, edgeLoop=mea, ass=0, q=1)
edgeName = '%s.e[%s]' % (self.polyName, str(int(edgeLoop[0])))
edgePos = cmds.xform(edgeName, ws=1, q=1, t=1)
if round(edgePos[0], 5) == 0:
edgeName = '%s.e[%s]' % (self.polyName, str(int(edgeLoop[-1])))
edgePos = cmds.xform(edgeName, ws=1, q=1, t=1)
if round(edgePos[0], 5) == 0:
intArray = [int(i) for i in edgeLoop]
if intArray not in middleEdgeArray:
middleEdgeArray.append(intArray)
return middleEdgeArray
def curveFromEdgeRing():
sel = cmds.ls(sl=True, fl=True)
avgPositionList = []
for s in sel:
cmds.select(s, r=True)
edgeNum = int(s.split('[')[1].replace(']', ''))
cmds.polySelect(elb=edgeNum)
edgeLoopVtxList = cmds.ls(cmds.polyListComponentConversion(cmds.ls(
sl=True, fl=True),
tv=True),
fl=True)
posXlist = []
posYlist = []
posZlist = []
for v in edgeLoopVtxList:
posXlist.append(cmds.pointPosition(v)[0])
posYlist.append(cmds.pointPosition(v)[1])
posZlist.append(cmds.pointPosition(v)[2])
avgPos = [
numpy.mean(posXlist),
numpy.mean(posYlist),
numpy.mean(posZlist)
]
avgPositionList.append(avgPos)
if len(avgPositionList) <= 1:
pass
else:
cmds.curve(d=3, p=avgPositionList)
def get_mesh_shell(self):
"""
Extend current :class:`Component` to contained mesh shell and return
new :class:`Component`.
:rtype: :class:`Component`
"""
faces = self.to_face()
shell = set()
for idx in faces.indices:
if idx in shell:
continue
shell.update(
cmds.polySelect(str(self.dagpath), q=True, ets=idx, ns=True)
)
faces.add(shell)
return faces.convert_to(self.type)
def create_link(self):
"""Creates a ring
Attributes:
linkNumber: What number of ring it is(the first is 0,
second is 1 ... ETC)
Returns:
Ring object
"""
#general transforms
ring = Ring(self.linkNumber, self.radius, self.linkRadius)
cmds.setAttr(ring.get_shape() + ".subdivisionsAxis",
4) # change subdivisions to get rectangular shape
cmds.setAttr(ring.get_transform() + ".rotateY",
45) # rotation in xz plane
cmds.polySelect(ring.get_transform(), el=100) # stretching the square
cmds.polySelect(ring.get_transform(), el=85, add=True)
cmds.polyMoveEdge(translateX=(float(-self.radius) *
(2.0 - math.sqrt(2)) / 2))
cmds.polySelect(ring.get_transform(),
el=90) # stretching the square at opposite corners
cmds.polySelect(ring.get_transform(), el=95, add=True)
cmds.polyMoveEdge(translateX=(float(self.radius) *
(2.0 - math.sqrt(2)) / 2))
#rotate along chain axis every 2nd link
if self.rotationState == True:
cmds.rotate(90, 0, 45, ring.get_transform(), ws=True)
#Makes the next ring rotate 90 deg
self.rotationState = not self.rotationState
self.linkNumber += 1
#stores the ring for later modifications
self.linkObjs.append(ring)
self.move_link(ring)
return ring
def getGeodesicDistancev2(mesh, v1Index, v2Index):
#Catch special case
if (v1Index == v2Index):
return 0
#Get the shortest edge path
sel = cmds.polySelect(mesh, shortestEdgePath=(v1Index, v2Index), ass=True )
#Calculate the path length
dist = 0
for i in range(len(sel)):
conv = cmds.polyListComponentConversion(sel[i], fe=True, tv=True)
conv = cmds.filterExpand(conv, sm=31)
dist += getEuclideanDistance(cmds.pointPosition(conv[0]), cmds.pointPosition(conv[1]))
return dist
def filterCrease(self,
polyName,
wholeDelArrayTemp,
isProtectCreaseLoop=True):
arrayWithoutCrease = []
noneCreaseArray = []
creaseArray = []
self.progress.setMaximum(len(wholeDelArrayTemp))
self.progress.setLabelText('filter Crease...')
self.progress.setValue(0)
for count, pwda in enumerate(wholeDelArrayTemp):
self.progress.setValue(count)
fullString = '%s.e[%s]' % (polyName, str(pwda))
cVal = cmds.polyCrease(fullString, q=1, value=1)
if cVal[0] <= 0:
noneCreaseArray.append(int(pwda))
else:
creaseArray.append(int(pwda))
creaseProtectArray = []
if isProtectCreaseLoop:
for i in creaseArray:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(i),
ass=0,
q=1)
for el in edgeLoop:
creaseProtectArray.append(int(el))
for i in noneCreaseArray:
if i not in creaseProtectArray:
arrayWithoutCrease.append(i)
else:
arrayWithoutCrease = list(noneCreaseArray)
return arrayWithoutCrease
def findAllShapes(obj):
faces = {}
faces = set()
faceCount = cmd.polyEvaluate(obj, f=True)
for i in range(faceCount):
faces.add(i)
d = dict()
i = 1
while len(faces) > 0:
if i > 100:
break
start = (faces.pop())
faces.add(start)
shellFaces = cmd.polySelect(obj, ets=start)
verts = cmd.polyListComponentConversion(ff=True, tv=True)
d[i] = verts
for this in shellFaces:
faces.remove(this)
i += 1
return (d)
def returnEdgeLoopFromEdge(polyEdge):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns an edgeloop from an edge
ARGUMENTS:
polyEdge(string)
RETURNS:
edgeList(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
splitBuffer = polyEdge.split('.')
polyObj = splitBuffer[0]
edges = mc.polySelect([polyObj],edgeLoop = (returnIndiceFromName(polyEdge)))
mc.select(cl=True)
edges = lists.returnListNoDuplicates(edges)
returnList = []
for edge in edges:
returnList.append('%s%s%i%s' %(polyObj,'.e[',edge,']'))
return returnList
def returnEdgeLoopFromEdge(polyEdge):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns an edgeloop from an edge
ARGUMENTS:
polyEdge(string)
RETURNS:
edgeList(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
splitBuffer = polyEdge.split('.')
polyObj = splitBuffer[0]
edges = mc.polySelect([polyObj],edgeLoop = (returnIndiceFromName(polyEdge)))
mc.select(cl=True)
edges = lists.returnListNoDuplicates(edges)
returnList = []
for edge in edges:
returnList.append('%s%s%i%s' %(polyObj,'.e[',edge,']'))
return returnList
def getBaseStructEdgeInformation(self,
polyName,
vertInformationDict,
delLevel=1):
cleanVertArray = vertInformationDict['keyVerts']
edgeLoopArray = []
# get the base struct edges.
vertToStructEdgeDict = {} # return value
simpleStructEdgeArray = []
for count, cva in enumerate(cleanVertArray):
vert = '%s.vtx[%s]' % (polyName, str(cva))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = self.cleanInfos(edgeInfo[0])
relativeList = []
for eid in edgeID:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(eid),
ass=0,
q=1)
if len(edgeLoop) > (
delLevel +
1): # filter the items which length not enough.
intArray = []
for el in edgeLoop:
intArray.append(int(el))
if intArray:
if intArray not in edgeLoopArray:
edgeLoopArray.append(intArray)
# collect information {vert:[edge1,edge2,...edge5]}}
if self.isEdgesListMirror(intArray):
spArray = self.splitLinesByMiddle([intArray])
for spa in spArray:
if int(eid) in spa:
relativeList.append(spa)
else:
relativeList.append(intArray)
vertToStructEdgeDict.update({str(cva): relativeList})
# restore edges start from key vert.
edgeLoopArrayWithoutMiddle = list(edgeLoopArray)
spEdgeLoopArray = self.splitLinesByMiddle(edgeLoopArray)
spEdgeLoopArray += (self.getMiddleEdgeByMiddleVerts(
vertInformationDict['middleVerts']))
edgeLoopArrayWithoutMiddle += (self.getMiddleEdgeByMiddleVerts(
vertInformationDict['middleVerts']))
# create struct weight
structWeightDict = {} # return value
for spela in spEdgeLoopArray:
structWeightDict.update({str(spela): 1})
# add edge weight(crease vertex)
creaseVertArray = vertInformationDict['creaseVerts']
if creaseVertArray:
for cva in creaseVertArray:
edgeArray = vertToStructEdgeDict[str(cva)]
for ea in edgeArray:
structWeightDict[str(ea)] += 1
structEdgeToVertsDict = {} # return value.very important
for spela in spEdgeLoopArray:
vertTempA = self.edgeListToVertList(spela)
intArray = []
for vta in vertTempA:
intArray.append(int(vta))
structEdgeToVertsDict.update({str(spela): intArray})
structEdges = []
for spela in spEdgeLoopArray:
#print spela
for sa in spela:
structEdges.append(int(sa))
return {
'keyVertToStructEdgeDict': vertToStructEdgeDict,
'structEdgeWeightDict': structWeightDict,
'structEdgeToVertsDict': structEdgeToVertsDict,
'structEdgeFlat': structEdges,
'edgeLoopArrayWithoutMiddle': edgeLoopArrayWithoutMiddle,
'structEdgeList': spEdgeLoopArray
}
def get_border_loop_indices_from_edge_index(index):
return set(sorted([int(i) for i in cmds.polySelect(q=True, edgeBorder=index)]))
def CreateDoorBase(self,
name="doorBase",
width=_wallbaseWidth,
height=_wallbaseHeight,
divisions=2):
if cmds.objExists(name):
return name
door = cmds.polyPlane(name=name,
w=1,
h=1,
sx=2,
sy=2,
cuv=2,
ch=1,
ax=[1, 0, 0])
cmds.move(0, height / 2, 0, a=True)
cmds.polySelect(name, edgeRing=1)
cmds.polyCrease(value=0.9)
cmds.select(f'{name}.f[0:]', r=True)
cmds.sets(e=True, forceElement=self._matWall)
offset = cmds.polyExtrudeFacet(constructionHistory=True,
keepFacesTogether=True,
offset=0.05,
divisions=divisions)
cmds.setAttr(f'{offset[0]}.localTranslate', 0, 0.05, 0)
cmds.scale(1, 1, 0.6, r=True, p=[0, 0.45, 0])
cmds.polyExtrudeFacet(constructionHistory=True,
keepFacesTogether=True,
thickness=0.05,
divisions=divisions)
cmds.sets(e=True, forceElement=self._matDoorFrame)
cmds.polyExtrudeFacet(constructionHistory=True,
keepFacesTogether=True,
offset=0.02,
divisions=divisions)
cmds.polyExtrudeFacet(constructionHistory=True,
keepFacesTogether=True,
thickness=-0.2,
divisions=divisions)
cmds.sets(e=True, forceElement=self._matDoor)
cmds.select(f'{name}.f[4:8]', r=True)
cmds.polyDelFacet()
cmds.select(door)
cmds.polyBevel3(fraction=0.1,
offsetAsFraction=1,
autoFit=1,
depth=1,
mitering=0,
miterAlong=0,
chamfer=0,
segments=2,
worldSpace=1,
smoothingAngle=30)
#freeze transformations
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0, pn=1)
return door[0]
import maya.cmds as cmds #create cylinder 8 subdivisions axis cylinder = cmds.polyCylinder(sx=8, sy=1, sz=1) #select edges cmds.polySelect(cylinder, edgeRing=(24, 26, 28, 30, 32, 34, 36, 38)) #delete selection cmds.delete()
def get_border_loop_indices_from_edge_index(index):
return set(
sorted([int(i) for i in cmds.polySelect(q=True, edgeBorder=index)]))
def change_chain(self, links=None, length=None, thickness=None):
"""modifies the chain properties. Links, length and thickness can
all be changed. EX: change_chain(self, links = int, length = float, thickness = float) """
#link number is flagged to change
if links:
changeInLinks = links - self.links
self.links = links
#if missing links create and parent links
if changeInLinks > 0:
for link in range(changeInLinks):
newRing = self.create_link()
cmds.parent(newRing.get_name(),
self.linkObjs[0].get_name())
newRing.add_parent(self.linkObjs[0].get_transform())
#if too many links. Ensure the root node is not deleted
elif changeInLinks < 0 and self.links > 1:
self.linkObjs[len(self.linkObjs) - 1].delete_link()
self.linkNumber -= 1
self.linkObjs.pop()
#length is flagged to change
if length:
for ring in self.linkObjs:
#reset the link to 0 for easier re-transform
magnitudeOfTranslate = (ring.get_ringNumber()) * (
self.radius) + (ring.get_ringNumber()) * (
self.radius - 2 * (self.linkRadius))
cmds.move(-magnitudeOfTranslate, 0, 0, ring.get_transform())
changeInRadius = self.radius - length
for ring in self.linkObjs:
# Prepare the variables for transforming
# pastTransformX = 0.8*(float(-self.radius)*(2.0-math.sqrt(2))/2)
self.radius = length
# newTransformX = 0.8*(float(-self.radius)*(2.0-math.sqrt(2))/2)
#reshape
cmds.polySelect(ring.get_transform(),
el=100) # stretching the square
cmds.polySelect(ring.get_transform(), el=85, add=True)
cmds.polyMoveEdge(translateX=(changeInRadius))
cmds.polySelect(ring.get_transform(),
el=100) # stretching the square z
cmds.polySelect(ring.get_transform(), el=95, add=True)
cmds.polyMoveEdge(translateZ=(changeInRadius))
cmds.polySelect(ring.get_transform(), el=90)
cmds.polySelect(ring.get_transform(), el=95, add=True)
cmds.polyMoveEdge(translateX=-(changeInRadius))
cmds.polySelect(ring.get_transform(),
el=85) # stretching the square z
cmds.polySelect(ring.get_transform(), el=90, add=True)
cmds.polyMoveEdge(translateZ=-(changeInRadius))
self.move_link(ring)
#thickness is flagged to change.
if thickness:
for ring in self.linkObjs:
#reset the link to 0 for easier re-transform
magnitudeOfTranslate = (ring.get_ringNumber()) * (
self.radius) + (ring.get_ringNumber()) * (
self.radius - 2 * (self.linkRadius))
cmds.move(-magnitudeOfTranslate, 0, 0, ring.get_transform())
# Prepare the variables for transforming
pastTransformX = 0.8 * (newTransformX - pastTransformX)
self.linkRadius = thickness
newTransformX = -0.8 * (newTransformX - pastTransformX)
#reshape
cmds.polySelect(ring.get_transform(),
el=100) # stretching the square
cmds.polySelect(ring.get_transform(), el=85, add=True)
cmds.polyMoveEdge(translateX=0.8 *
(newTransformX - pastTransformX))
cmds.polySelect(ring.get_transform(), el=90)
cmds.polySelect(ring.get_transform(), el=95, add=True)
cmds.polyMoveEdge(translateX=-0.8 *
(newTransformX - pastTransformX))
self.move_link(ring)
EDGE_STEP = 7
# select startEdge, then endEdge
selEdges = mc.ls(sl=1)[0:2]
endEdgeUndo = mc.undoInfo(q=1, un=1)
prefix = selEdges[0].split('[')[0]
endEdgeIndex = int(endEdgeUndo.split('[')[1][:-2])
selEdgesIndex = [int(edgeName.split('[')[1][:-1]) for edgeName in selEdges]
for eachEdge in selEdgesIndex:
if eachEdge != endEdgeIndex:
startEdgeIndex = eachEdge
break
edgeLoopIndices = mc.polySelect(elp=[startEdgeIndex, endEdgeIndex], ns=1)
edgeLoop = ['%s[%d]'%(prefix, edgeIndex) for edgeIndex in edgeLoopIndices]
if edgeLoopIndices[-1] == startEdgeIndex:
edgeLoop.reverse()
edgeLoopIndices.reverse()
centerPositions = []
# loop through edges to store center positions
for i in range(len(edgeLoop)-1):
currEdge = edgeLoop[i]
currEdgeIndex = edgeLoopIndices[i]
nextEdge = edgeLoop[i+1]
nextEdgeIndex = edgeLoopIndices[i+1]
currRing = mc.polySelect(er=currEdgeIndex, ns=1, ass=1)
def calculateBaseDeleteArray(self, polyName, delLevel=1):
# delLevel attr means smooth level 1 to reverse
divAttr = delLevel + 1
edgeArrayTemp = self.getBaseStructEdges(polyName)
if edgeArrayTemp:
edgeArray = edgeArrayTemp[0]
addWeightStructEdges = edgeArrayTemp[1]
else:
return False
# every item in the array is unique.it's all fine.
self.progress.setMaximum(len(edgeArray))
self.progress.setLabelText('clean data..')
self.progress.setValue(0)
wholeEdges = []
for i in edgeArray:
wholeEdges += i
# ================== main part =================================
selEdgeArray = []
for count, ela in enumerate(edgeArray):
self.progress.setValue(count)
if len(ela) >= divAttr:
# make data form.when divAttr equel 1,we need two item to calculate.
# divAttr = 2 -> item length = 3
# divAttr = 3 -> item length = 4
divWorkArray = [
ela[i:i + divAttr] for i in range(0, len(ela), divAttr)
]
# check array struct,is it 100% fit? if more or less.then removed them.
for dwacheck in divWorkArray:
if len(dwacheck) != divAttr:
divWorkArray.remove(dwacheck)
# collect the point on curve,who need to delete under base rule.
delVertInEdge = []
for dwa in divWorkArray:
tempArray = []
targetArray = []
for i in dwa:
edge = '%s.e[%s]' % (polyName, str(i))
vtx = cmds.polyInfo(edge, edgeToVertex=1)
vtxID = self.cleanInfos(vtx[0])
for vid in vtxID:
if int(vid) in tempArray:
targetArray.append(int(vid))
else:
tempArray.append(int(vid))
delVertInEdge += targetArray
# now we need convert the vert to the edge who crossed base struct edges.
crossEdges = []
for dvi in delVertInEdge:
vert = '%s.vtx[%s]' % (polyName, str(dvi))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = self.cleanInfos(edgeInfo[0])
# rule 1.the line can not in the base protect array.
# in the touch point.there're two edges in base protect array.
# now i need collect all of rest items.
cellArray = []
for eid in edgeID:
if not (int(eid) in wholeEdges):
cellArray.append(int(eid))
crossEdges.append(cellArray)
selEdgeArray.append(crossEdges)
# ================== main part end =================================
# ================== add cease vert weight part =================================
# calculate the edges who need add weight.
# program as same as the main function of this def.
# just use a another array and loop again.
# addWeightStructEdges
addWeightEdgeArray = []
self.progress.setValue(0)
for count, ela in enumerate(addWeightStructEdges):
self.progress.setValue(count)
if len(ela) >= divAttr:
# make data form.when divAttr equel 1,we need two item to calculate.
# divAttr = 2 -> item length = 3
# divAttr = 3 -> item length = 4
divWorkArray = [
ela[i:i + divAttr] for i in range(0, len(ela), divAttr)
]
# check array struct,is it 100% fit? if more or less.then removed them.
for dwacheck in divWorkArray:
if len(dwacheck) != divAttr:
divWorkArray.remove(dwacheck)
# collect the point on curve,who need to delete under base rule.
delVertInEdge = []
for dwa in divWorkArray:
tempArray = []
targetArray = []
for i in dwa:
edge = '%s.e[%s]' % (polyName, str(i))
vtx = cmds.polyInfo(edge, edgeToVertex=1)
vtxID = self.cleanInfos(vtx[0])
for vid in vtxID:
if int(vid) in tempArray:
targetArray.append(int(vid))
else:
tempArray.append(int(vid))
delVertInEdge += targetArray
# now we need convert the vert to the edge who crossed base struct edges.
crossEdges = []
for dvi in delVertInEdge:
vert = '%s.vtx[%s]' % (polyName, str(dvi))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = self.cleanInfos(edgeInfo[0])
# rule 1.the line can not in the base protect array.
# in the touch point.there're two edges in base protect array.
# now i need collect all of rest items.
cellArray = []
for eid in edgeID:
if not (int(eid) in wholeEdges):
cellArray.append(int(eid))
crossEdges.append(cellArray)
addWeightEdgeArray.append(crossEdges)
# ================== add cease vert weight part end =================================
countWeightTemp = addWeightEdgeArray + selEdgeArray
self.progress.setMaximum(len(countWeightTemp))
self.progress.setLabelText('clean data....')
self.progress.setValue(0)
wholeDelArrayTemp = []
countDict = {}
# edge weights dict. very important.
for count, gg in enumerate(countWeightTemp):
self.progress.setValue(count)
for ce in gg:
if ce:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(ce[0]),
ass=0,
q=1)
edgeLoop.sort()
strEdge = str(edgeLoop)
if strEdge not in countDict.keys():
countDict.update({strEdge: 5})
else:
countDict[strEdge] += 1
'''
isFound = False
for awe in addWeightEdgeArray:
if ce in awe:
isFound = True
if isFound:
countDict.update({strEdge:7})
'''
# ==========================================
vertToKeyDict = {}
vertToWeightDict = {}
edgeArray # defined at the fist of def
teamVertsByEdgeArray = []
for ea in edgeArray:
tempArray = []
for i in ea:
edge = '%s.e[%s]' % (polyName, str(i))
vtx = cmds.polyInfo(edge, edgeToVertex=1)
vtxID = self.cleanInfos(vtx[0])
for vid in vtxID:
if int(vid) not in tempArray:
tempArray.append(int(vid))
teamVertsByEdgeArray.append(tempArray)
crossEdges = []
for tvbea in teamVertsByEdgeArray:
for tvb in tvbea:
vert = '%s.vtx[%s]' % (polyName, str(tvb))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = self.cleanInfos(edgeInfo[0])
# rule 1.the line can not in the base protect array.
# in the touch point.there're two edges in base protect array.
# now i need collect all of rest items.
cellArray = []
for eid in edgeID:
if not (int(eid) in wholeEdges):
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(eid),
ass=0,
q=1)
cellArray.append(edgeLoop)
break
if cellArray:
crossEdges.append(cellArray)
#print '^^^^^'
#for ce in crossEdges:
# print ce
#print len(crossEdges)
#print '^^^^^'
# ==========================================
# remove edges.just keep weight <= 5.
# as high weight as confirm the edge have to be deleted.
collectArray = []
for key, val in countDict.items():
if val > 5:
keytemp = key.split(',')
collectList = []
for kt in keytemp:
digitTemp = ''
for k in kt:
if k.isdigit():
digitTemp += k
digitVal = int(digitTemp)
collectList.append(digitVal)
collectArray.append(collectList)
for cc in collectArray:
for c in cc:
wholeDelArrayTemp.append(c)
return [collectArray, wholeDelArrayTemp]
def calculateBaseDeleteArray(polyName, delLevel=1):
# delLevel attr means smooth level 1 to reverse
divAttr = delLevel + 1
edgeArray = getBaseStructEdges(polyName)
# every item in the array is unique.it's all fine.
wholeEdges = []
for i in edgeArray:
wholeEdges += i
selEdgeArray = []
for ela in edgeArray:
if len(ela) >= divAttr:
# make data form.when divAttr equel 1,we need two item to calculate.
# divAttr = 2 -> item length = 3
# divAttr = 3 -> item length = 4
divWorkArray = [
ela[i:i + divAttr] for i in range(0, len(ela), divAttr)
]
# check array struct,is it 100% fit? if more or less.then removed them.
for dwacheck in divWorkArray:
if len(dwacheck) != divAttr:
divWorkArray.remove(dwacheck)
# collect the point on curve,who need to delete under base rule.
delVertInEdge = []
for dwa in divWorkArray:
tempArray = []
targetArray = []
for i in dwa:
edge = '%s.e[%s]' % (polyName, str(i))
vtx = cmds.polyInfo(edge, edgeToVertex=1)
vtxID = cleanInfos(vtx[0])
for vid in vtxID:
if int(vid) in tempArray:
targetArray.append(int(vid))
else:
tempArray.append(int(vid))
delVertInEdge += targetArray
# now we need convert the vert to the edge who crossed base struct edges.
crossEdges = []
for dvi in delVertInEdge:
vert = '%s.vtx[%s]' % (polyName, str(dvi))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = cleanInfos(edgeInfo[0])
# rule 1.the line can not in the base protect array.
# in the touch point.there're two edges in base protect array.
# now i need collect all of rest items.
cellArray = []
for eid in edgeID:
if not (int(eid) in wholeEdges):
cellArray.append(int(eid))
crossEdges.append(cellArray)
#selEdgeByIntArray(polyName,crossEdges)
selEdgeArray.append(crossEdges)
delArrayTemp = []
wholeDelArrayTemp = []
for gg in selEdgeArray:
for ce in gg:
if ce:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(ce[0]),
ass=0,
q=1)
delArrayTemp.append(edgeLoop)
for el in edgeLoop:
intEl = int(el)
if not (intEl in wholeDelArrayTemp):
wholeDelArrayTemp.append(intEl)
return [delArrayTemp, wholeDelArrayTemp]
def getBaseStructEdges(self, polyName):
vertArrayTemp = self.getAllVertsWhoHave5edges(polyName)
if vertArrayTemp:
cleanVertArray = vertArrayTemp[0]
midEdgeArray = vertArrayTemp[1]
creaseVertexArray = vertArrayTemp[2]
self.progress.setMaximum(len(cleanVertArray))
self.progress.setLabelText('struct data...')
self.progress.setValue(0)
edgeLoopArray = []
sortTemp = []
# get the base struct edges on normal way.
for count, cva in enumerate(cleanVertArray):
self.progress.setValue(count)
vert = '%s.vtx[%s]' % (polyName, str(cva))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = self.cleanInfos(edgeInfo[0])
for eid in edgeID:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(eid),
ass=0,
q=1)
intArray = []
for el in edgeLoop:
intArray.append(int(el))
sEdgeLoop = list(intArray)
sEdgeLoop.sort()
if not (sEdgeLoop in sortTemp):
edgeLoopArray.append(intArray)
sortTemp.append(sEdgeLoop)
# if middle edges exists.add middle edges into array.
strTemp = []
if midEdgeArray:
for mea in midEdgeArray:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=mea,
ass=0,
q=1)
strLoop = str(edgeLoop)
if strLoop not in strTemp:
strTemp.append(strLoop)
edgeLoopArray.append(edgeLoop)
# before this line.for loop have a filter to split the multiple occurrence edges.
# so we need add the edges who defined by crease vertex after filter.
# add edges weight by crease verts.
addWeightStructEdges = []
for cva in creaseVertexArray:
vert = '%s.vtx[%s]' % (polyName, str(cva))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = self.cleanInfos(edgeInfo[0])
for eid in edgeID:
edgeLoop = cmds.polySelect(polyName,
edgeLoop=int(eid),
ass=0,
q=1)
intArray = []
for el in edgeLoop:
intArray.append(int(el))
addWeightStructEdges.append(intArray)
return [edgeLoopArray, addWeightStructEdges]
else:
return False
def SelectEdges(self):
""" Select edges of a poly object """
cmds.polyCube(n="pCube1", ch=False)
cmds.polySelect('pCube1', edgeRing=1)
cmds.polySelect('pCube1', toggle=True, edgeRingPath=(0, 1))
for one in cvs:
cmd.select(one)
cmd.cluster(name='%s%d%s'% (name, i, type))
cmd.group(name='%s%d%sGP'% (name, i, type))
i += 1
cvsToCLR()
#select edgeLoop from edge
import re
import maya.cmds as cmd
edge = cmd.ls(sl=True)
id = re.findall('\d+',(edge[0].split('.')[1]))
cmd.polySelect(el=int(id[0]))
[('pointOnSurfaceInfo', 'pos', u'pos4'),
('loft', 'lft', u'lft'),
('fourByFourMatrix', 'mat', u'mat'),
('decomposeMatrix', 'dcp', u'dcp')]
def lotteryPicker(numTix, picks, possible):
import random
import time
import math
possible += 1
start_time = time.time()
n = math.factorial(possible)
#selVertByIntArray(polyName,delVertInEdge)
#now we need convert the vert to the edge who crossed base struct edges.
#print holeEdge
crossEdges = []
for dvi in delVertInEdge:
vert = '%s.vtx[%s]' % (polyName, str(dvi))
edgeInfo = cmds.polyInfo(vert, vertexToEdge=1)
edgeID = cleanInfos(edgeInfo[0])
for eid in edgeID:
if not (int(eid) in holeEdge):
crossEdges.append(int(eid))
break
# if i removed 'break'.then will get two edges.i don't have to do that
#selEdgeByIntArray(polyName,crossEdges)
selEdgeArray.append(crossEdges)
print selEdgeArray
for gg in selEdgeArray:
for ce in gg:
edgeLoop = cmds.polySelect(polyName, edgeLoop=int(ce), ass=0, q=1)
selEdgeByIntArray(polyName, edgeLoop, add=1)
def makeSym(*args):
selLs = cmds.ls(sl = True)
# When user select center edge loop.
if '.e' in selLs[0]:
numOfShells = cmds.polyEvaluate(shell = True)
if numOfShells > 1:
cmds.confirmDialog(title = 'Warning', message = 'Selected mesh is made of combining several geometry.\nSeparate mesh and try it again.')
return False
centerEdgeLoop = selLs
objName = centerEdgeLoop[0].split('.')[0]
uvKeepGeo = cmds.duplicate(objName, n = '{0}_uvKeep_geo'.format(objName))
mel.eval('PolySelectConvert 3;')
tak_misc.zeroVtx()
cmds.select(centerEdgeLoop, r = True)
cmds.DetachComponent()
leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName)
symOpt = cmds.radioButtonGrp('symOptRadButGrp', q = True, select = True)
# If user select 'x to -x' mean left to right.
if symOpt == 1:
rightestVtx = getSidestVtx(rightVtxDic)
cmds.select(rightestVtx, r = True)
mel.eval('PolySelectConvert 1;') # Convert vertex selection to face.
rightestFace = cmds.ls(sl = True, fl = True)[0]
rightestFaceId = int(re.search(r'.+f\[(\d+)\]', rightestFace).group(1))
cmds.polySelect(extendToShell = rightestFaceId)
cmds.delete()
# mirror geometry
mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, mergeMode = 0, mergeThreshold = 0.001, ch = True)
cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0)
# If user select '-x to x' mean right to left.
if symOpt == 2:
leftestVtx = getSidestVtx(leftVtxDic)
cmds.select(leftestVtx, r = True)
mel.eval('PolySelectConvert 1;') # Convert vertex selection to face.
leftestFace = cmds.ls(sl = True, fl = True)[0]
leftestFaceId = int(re.search(r'.+f\[(\d+)\]', leftestFace).group(1))
cmds.polySelect(extendToShell = leftestFaceId)
cmds.delete()
# mirror geometry
mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, mergeMode = 0, mergeThreshold = 0.001, ch = True)
cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0)
# When user select object.
else:
objName = selLs[0]
uvKeepGeo = cmds.duplicate(objName, n = '{0}_uvKeep_geo'.format(objName))
leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName)
symOpt = cmds.radioButtonGrp('symOptRadButGrp', q = True, select = True)
if centerVtxDic.keys():
cmds.select(centerVtxDic.keys(), r = True)
mel.eval('SelectEdgeLoopSp;')
tak_misc.zeroVtx()
leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName) # Refresh vertex position information.
# If user select 'x to -x' mean left to right.
if symOpt == 1:
cmds.select(rightVtxDic.keys(), r = True)
mel.eval('PolySelectConvert 1;') # Convert vertex selection to face.
cmds.delete()
# mirror geometry
mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, ch = True)
cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0)
# If user select 'x to -x' mean right to left.
if symOpt == 2:
cmds.select(leftVtxDic.keys(), r = True)
mel.eval('PolySelectConvert 1;') # Convert vertex selection to face.
cmds.delete()
# mirror geometry
mirrorNode = cmds.polyMirrorFace(objName, ws = True, direction = 1, ch = True)
cmds.polyMirrorFace(mirrorNode, e = True, pivotX = 0.0)
leftVtxDic, rightVtxDic, centerVtxDic = getVtxInfo(objName)
if centerVtxDic.keys():
cmds.select(centerVtxDic.keys(), r = True)
cmds.polyMergeVertex(distance = 0.001)
# Copy uv from uv keeped geometry to new symmetrized geometry.
smpSpc = cmds.radioButtonGrp('symSmpSpcRdoBtn', q = True, select = True)
if smpSpc == 2:
smpSpc = 4
elif smpSpc == 3:
smpSpc = 5
cmds.transferAttributes(uvKeepGeo, objName, transferUVs = 2, sampleSpace = smpSpc)
# cmds.select(objName, r = True)
# mel.eval("SoftPolyEdgeElements 1;")
# cmds.select(objName, r = True)
# mel.eval('polyNormalPerVertex -ufn true;')
cmds.delete(objName, ch = True)
cmds.delete(uvKeepGeo)
cmds.select(objName, r = True)
CENTER_CRV = True
EDGE_STEP = 7
# select startEdge, then endEdge
selEdges = mc.ls(sl=1)[0:2]
endEdgeUndo = mc.undoInfo(q=1, un=1)
prefix = selEdges[0].split('[')[0]
endEdgeIndex = int(endEdgeUndo.split('[')[1][:-2])
selEdgesIndex = [int(edgeName.split('[')[1][:-1]) for edgeName in selEdges]
for eachEdge in selEdgesIndex:
if eachEdge != endEdgeIndex:
startEdgeIndex = eachEdge
break
edgeLoopIndices = mc.polySelect(elp=[startEdgeIndex, endEdgeIndex], ns=1)
edgeLoop = ['%s[%d]' % (prefix, edgeIndex) for edgeIndex in edgeLoopIndices]
if edgeLoopIndices[-1] == startEdgeIndex:
edgeLoop.reverse()
edgeLoopIndices.reverse()
centerPositions = []
# loop through edges to store center positions
for i in range(len(edgeLoop) - 1):
currEdge = edgeLoop[i]
currEdgeIndex = edgeLoopIndices[i]
nextEdge = edgeLoop[i + 1]
nextEdgeIndex = edgeLoopIndices[i + 1]
currRing = mc.polySelect(er=currEdgeIndex, ns=1, ass=1)
def ES_TestCreate():
cmds.polySphere(n='Object001')
cmds.polySelect('Object001', toggle=True, edgeLoop=180)
